| ID |
Date |
Author |
Topic |
Subject |
|
760
|
10 May 2011 |
Pierre-Andre Amaudruz | Forum | simple example frontend for V1720 |
| Jianglai Liu wrote: | Hi,
Who has a good example of a frontend program using CAEN V1718 VME-USB bridge and
V1720 FADC? I am trying to set up the DAQ for such a simple system.
I put together a frontend which talks to the VME. However it gets stuck at
"Calibrating" in initialize_equipment().
I'd appreciate some help!
Thanks,
Jianglai |
Under the drivers/vme you can find code for the v1720.c (VME access) and ov1720.c
(A2818/A3818 PCIe optical link access). For testing the hardware, we use this code compiled and linked
with MAIN_ENABLE to confirm its functionality. You may want to do the same for your USB. Once this
is under control, the Midas frontend implementation using the same driver shouldn't give you trouble. |
|
761
|
18 May 2011 |
Jimmy Ngai | Forum | simple example frontend for V1720 |
| Jianglai Liu wrote: | Hi,
Who has a good example of a frontend program using CAEN V1718 VME-USB bridge and
V1720 FADC? I am trying to set up the DAQ for such a simple system.
I put together a frontend which talks to the VME. However it gets stuck at
"Calibrating" in initialize_equipment().
I'd appreciate some help!
Thanks,
Jianglai |
Hi Jianglai,
I don't have an exmaple of using V1718 with V1720, but I have been using V1718 with V792N for a long time.
You may find in the attachment an example frontend program and my drivers for V1718 and V792N written in MVMESTD format. They have to be linked with the CAENVMELib library and other essential MIDAS stuffs.
Regards,
Jimmy |
| Attachment 1: frontend.c
|
/********************************************************************\
Name: frontend.c
Created by: Jimmy Ngai
Date: May 9, 2010
Contents: Experiment specific readout code (user part) of
Midas frontend.
Supported VME modules:
CAEN V1718 VME-USB Bridge
CAEN V792N 16 CH QDC
$Id: $
\********************************************************************/
#include <stdio.h>
#include <stdlib.h>
#include "midas.h"
#include "mcstd.h"
#include "mvmestd.h"
#include "experim.h"
#include "vme/v792n.h"
/* make frontend functions callable from the C framework */
#ifdef __cplusplus
extern "C" {
#endif
/*-- Globals -------------------------------------------------------*/
/* The frontend name (client name) as seen by other MIDAS clients */
char *frontend_name = "Frontend";
/* The frontend file name, don't change it */
char *frontend_file_name = __FILE__;
/* frontend_loop is called periodically if this variable is TRUE */
BOOL frontend_call_loop = FALSE;
/* a frontend status page is displayed with this frequency in ms */
INT display_period = 3000;
/* maximum event size produced by this frontend */
INT max_event_size = 10000;
/* maximum event size for fragmented events (EQ_FRAGMENTED) */
INT max_event_size_frag = 5 * 1024 * 1024;
/* buffer size to hold events */
INT event_buffer_size = 10 * 10000;
/* number of channels */
#define N_ADC 16
/* VME hardware */
MVME_INTERFACE *myvme;
/* VME base address */
DWORD V1718_BASE = 0x12000000;
DWORD V792N_BASE = 0x32100000;
/*-- Function declarations -----------------------------------------*/
INT frontend_init();
INT frontend_exit();
INT begin_of_run(INT run_number, char *error);
INT end_of_run(INT run_number, char *error);
INT pause_run(INT run_number, char *error);
INT resume_run(INT run_number, char *error);
INT frontend_loop();
INT read_trigger_event(char *pevent, INT off);
/*-- Equipment list ------------------------------------------------*/
#undef USE_INT
EQUIPMENT equipment[] = {
{"Trigger", /* equipment name */
{1, 0, /* event ID, trigger mask */
"SYSTEM", /* event buffer */
#ifdef USE_INT
EQ_INTERRUPT, /* equipment type */
#else
EQ_POLLED, /* equipment type */
#endif
LAM_SOURCE(CRATE, LAM_STATION(SLOT_ADC)), /* event source */
"MIDAS", /* format */
TRUE, /* enabled */
RO_RUNNING | /* read only when running */
RO_ODB, /* and update ODB */
500, /* poll for 500ms */
0, /* stop run after this event limit */
0, /* number of sub events */
0, /* don't log history */
"", "", "",},
read_trigger_event, /* readout routine */
},
{""}
};
#ifdef __cplusplus
}
#endif
/********************************************************************\
Callback routines for system transitions
These routines are called whenever a system transition like start/
stop of a run occurs. The routines are called on the following
occations:
frontend_init: When the frontend program is started. This routine
should initialize the hardware.
frontend_exit: When the frontend program is shut down. Can be used
to releas any locked resources like memory, commu-
nications ports etc.
begin_of_run: When a new run is started. Clear scalers, open
rungates, etc.
end_of_run: Called on a request to stop a run. Can send
end-of-run event and close run gates.
pause_run: When a run is paused. Should disable trigger events.
resume_run: When a run is resumed. Should enable trigger events.
\********************************************************************/
INT init_vme_modules()
{
/* default settings */
v792n_SoftReset(myvme, V792N_BASE);
v792n_Setup(myvme, V792N_BASE, 2);
// v792n_Status(myvme, V792N_BASE);
return SUCCESS;
}
/*-- Frontend Init -------------------------------------------------*/
INT frontend_init()
{
INT status;
/* open VME interface */
status = mvme_open(&myvme, 0);
/* set am to A32 non-privileged Data */
mvme_set_am(myvme, MVME_AM_A32_ND);
/* initialize all VME modules */
init_vme_modules();
v792n_OfflineSet(myvme, V792N_BASE);
v792n_DataClear(myvme, V792N_BASE);
/* print message and return FE_ERR_HW if frontend should not be started */
if (status != MVME_SUCCESS) {
cm_msg(MERROR, "frontend_init", "VME interface could not be opened.");
return FE_ERR_HW;
}
return SUCCESS;
}
/*-- Frontend Exit -------------------------------------------------*/
INT frontend_exit()
{
/* close VME interface */
mvme_close(myvme);
return SUCCESS;
}
/*-- Begin of Run --------------------------------------------------*/
INT begin_of_run(INT run_number, char *error)
{
/* Initialize all VME modules */
// init_vme_modules();
v792n_DataClear(myvme, V792N_BASE);
v792n_OnlineSet(myvme, V792N_BASE);
return SUCCESS;
}
/*-- End of Run ----------------------------------------------------*/
INT end_of_run(INT run_number, char *error)
{
v792n_OfflineSet(myvme, V792N_BASE);
v792n_DataClear(myvme, V792N_BASE);
return SUCCESS;
}
/*-- Pause Run -----------------------------------------------------*/
INT pause_run(INT run_number, char *error)
{
v792n_OfflineSet(myvme, V792N_BASE);
return SUCCESS;
}
/*-- Resuem Run ----------------------------------------------------*/
INT resume_run(INT run_number, char *error)
{
v792n_OnlineSet(myvme, V792N_BASE);
return SUCCESS;
}
/*-- Frontend Loop -------------------------------------------------*/
INT frontend_loop()
{
/* if frontend_call_loop is true, this routine gets called when
the frontend is idle or once between every event */
return SUCCESS;
}
/*------------------------------------------------------------------*/
/********************************************************************\
Readout routines for different events
\********************************************************************/
/*-- Trigger event routines ----------------------------------------*/
INT poll_event(INT source, INT count, BOOL test)
/* Polling routine for events. Returns TRUE if event
is available. If test equals TRUE, don't return. The test
flag is used to time the polling */
{
INT i;
DWORD lam = 0;
for (i = 0; i < count; i++) {
lam = v792n_DataReady(myvme, V792N_BASE);
if (lam)
if (!test)
return lam;
}
return 0;
}
/*-- Interrupt configuration ---------------------------------------*/
INT interrupt_configure(INT cmd, INT source, POINTER_T adr)
{
switch (cmd) {
case CMD_INTERRUPT_ENABLE:
break;
case CMD_INTERRUPT_DISABLE:
break;
case CMD_INTERRUPT_ATTACH:
break;
case CMD_INTERRUPT_DETACH:
break;
}
return SUCCESS;
}
/*-- Event readout -------------------------------------------------*/
INT read_v792n(INT base, const char *bk_name, char *pevent, INT n_chn)
{
INT i;
INT nentry = 0, counter;
DWORD data[V792N_MAX_CHANNELS+2];
WORD *pdata;
/* event counter */
// v792n_EvtCntRead(myvme, base, &counter);
/* read event */
v792n_EventRead(myvme, base, data, &nentry);
/* clear ADC */
// v792n_DataClear(myvme, base);
/* create ADC bank */
bk_create(pevent, bk_name, TID_WORD, &pdata);
... 29 more lines ...
|
| Attachment 2: v1718.h
|
/*********************************************************************
Name: v1718.h
Created by: Jimmy Ngai
Contents: V1718 VME-USB2.0 bridge include
$Id: $
*********************************************************************/
#ifndef V1718_INCLUDE_H
#define V1718_INCLUDE_H
#include <stdio.h>
#include <string.h>
#include "mvmestd.h"
#ifdef __cplusplus
extern "C" {
#endif
#define V1718_STATUS_RO (DWORD) (0x0000)
#define V1718_VME_CTRL_RW (DWORD) (0x0001)
#define V1718_FW_REV_RO (DWORD) (0x0002)
#define V1718_FW_DWNLD_RW (DWORD) (0x0003)
#define V1718_FL_ENA_RW (DWORD) (0x0004)
#define V1718_IRQ_STAT_RO (DWORD) (0x0005)
#define V1718_IN_REG_RW (DWORD) (0x0008)
#define V1718_OUT_REG_S_RW (DWORD) (0x000A)
#define V1718_IN_MUX_S_RW (DWORD) (0x000B)
#define V1718_OUT_MUX_S_RW (DWORD) (0x000C)
#define V1718_LED_POL_S_RW (DWORD) (0x000D)
#define V1718_OUT_REG_C_WO (DWORD) (0x0010)
#define V1718_IN_MUX_C_WO (DWORD) (0x0011)
#define V1718_OUT_MAX_C_WO (DWORD) (0x0012)
#define V1718_LED_POL_C_WO (DWORD) (0x0013)
#define V1718_PULSEA_0_RW (DWORD) (0x0016)
#define V1718_PULSEA_1_RW (DWORD) (0x0017)
#define V1718_PULSEB_0_RW (DWORD) (0x0019)
#define V1718_PULSEB_1_RW (DWORD) (0x001A)
#define V1718_SCALER0_RW (DWORD) (0x001C)
#define V1718_SCALER1_RO (DWORD) (0x001D)
#define V1718_DISP_ADL_RO (DWORD) (0x0020)
#define V1718_DISP_ADH_RO (DWORD) (0x0021)
#define V1718_DISP_DTL_RO (DWORD) (0x0022)
#define V1718_DISP_DTH_RO (DWORD) (0x0023)
#define V1718_DISP_PC1_RO (DWORD) (0x0024)
#define V1718_DISP_PC2_RO (DWORD) (0x0025)
#define V1718_LM_ADL_RW (DWORD) (0x0028)
#define V1718_LM_ADH_RW (DWORD) (0x0029)
#define V1718_LM_C_RW (DWORD) (0x002C)
WORD v1718_Read16(MVME_INTERFACE *mvme, DWORD base, int offset);
void v1718_Write16(MVME_INTERFACE *mvme, DWORD base, int offset, WORD value);
DWORD v1718_Read32(MVME_INTERFACE *mvme, DWORD base, int offset);
void v1718_Write32(MVME_INTERFACE *mvme, DWORD base, int offset, DWORD value);
void v1718_MultiRead(MVME_INTERFACE *mvme, DWORD *addrs, DWORD *value, int ncycle, int *am, int *dmode);
void v1718_MultiWrite(MVME_INTERFACE *mvme, DWORD *addrs, DWORD *value, int ncycle, int *am, int *dmode);
void v1718_MultiRead16(MVME_INTERFACE *mvme, DWORD *addrs, WORD *value, int ncycle);
void v1718_MultiWrite16(MVME_INTERFACE *mvme, DWORD *addrs, WORD *value, int ncycle);
void v1718_MultiRead32(MVME_INTERFACE *mvme, DWORD *addrs, DWORD *value, int ncycle);
void v1718_MultiWrite32(MVME_INTERFACE *mvme, DWORD *addrs, DWORD *value, int ncycle);
void v1718_PulserConfSet(MVME_INTERFACE *mvme, WORD pulser, DWORD period, DWORD width, WORD pulseNo);
void v1718_PulserStart(MVME_INTERFACE *mvme, WORD pulser);
void v1718_PulserStop(MVME_INTERFACE *mvme, WORD pulser);
enum v1718_PulserSelect {
v1718_pulserA=0x0,
v1718_pulserB=0x1,
};
#ifdef __cplusplus
}
#endif
#endif // V1718_INCLUDE_H
/* emacs
* Local Variables:
* mode:C
* mode:font-lock
* tab-width: 8
* c-basic-offset: 2
* End:
*/
|
| Attachment 3: v1718.c
|
/********************************************************************
Name: v1718.c
Created by: Jimmy Ngai
Contents: Midas VME standard (MVMESTD) layer for CAEN V1718
VME-USB2.0 Bridge using CAENVMElib Linux library
$Id: $
\********************************************************************/
#ifdef __linux__
#ifndef OS_LINUX
#define OS_LINUX
#endif
#endif
#ifdef OS_LINUX
#define _GNU_SOURCE
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include "CAENVMElib.h"
#endif // OS_LINUX
#include "v1718.h"
/*------------------------------------------------------------------*/
/********************************************************************\
MIDAS VME standard (MVMESTD) functions
\********************************************************************/
int mvme_open(MVME_INTERFACE **vme, int idx)
{
*vme = (MVME_INTERFACE *) malloc(sizeof(MVME_INTERFACE));
if (*vme == NULL)
return MVME_NO_MEM;
memset(*vme, 0, sizeof(MVME_INTERFACE));
/* open VME */
if (CAENVME_Init(cvV1718, 0, idx, &(*vme)->handle) != cvSuccess)
return MVME_NO_INTERFACE;
/* default values */
(*vme)->am = MVME_AM_DEFAULT;
(*vme)->dmode = MVME_DMODE_D32;
(*vme)->blt_mode = MVME_BLT_NONE;
(*vme)->table = NULL; // not used
return MVME_SUCCESS;
}
/*------------------------------------------------------------------*/
int mvme_close(MVME_INTERFACE *vme)
{
CAENVME_End(vme->handle);
free(vme);
return MVME_SUCCESS;
}
/*------------------------------------------------------------------*/
int mvme_sysreset(MVME_INTERFACE *vme)
{
CAENVME_SystemReset(vme->handle);
return MVME_SUCCESS;
}
/*------------------------------------------------------------------*/
int mvme_write(MVME_INTERFACE *vme, mvme_addr_t vme_addr, void *src, mvme_size_t n_bytes)
{
mvme_size_t i;
int status=0, n;
int hvme;
hvme = vme->handle;
n = 0;
/* D8 */
if (vme->dmode == MVME_DMODE_D8) {
for (i=0 ; i<n_bytes ; i++)
status = CAENVME_WriteCycle(hvme, vme_addr, src+i, vme->am, cvD8);
n = n_bytes;
/* D16 */
} else if (vme->dmode == MVME_DMODE_D16) {
/* normal I/O */
if (vme->blt_mode == MVME_BLT_NONE) {
for (i=0 ; i<(n_bytes>>1) ; i++)
status = CAENVME_WriteCycle(hvme, vme_addr, src+(i<<1), vme->am, cvD16);
n = n_bytes;
/* FIFO BLT */
} else if ((vme->blt_mode == MVME_BLT_BLT32FIFO) || (vme->blt_mode == MVME_BLT_MBLT64FIFO))
status = CAENVME_FIFOBLTWriteCycle(hvme, vme_addr, src, n_bytes, vme->am, cvD16, &n);
/* BLT */
else
status = CAENVME_BLTWriteCycle(hvme, vme_addr, src, n_bytes, vme->am, cvD16, &n);
/* D32 */
} else if (vme->dmode == MVME_DMODE_D32) {
/* normal I/O */
if (vme->blt_mode == MVME_BLT_NONE) {
for (i=0 ; i<(n_bytes>>2) ; i++)
status = CAENVME_WriteCycle(hvme, vme_addr, src+(i<<2), vme->am, cvD32);
n = n_bytes;
/* FIFO BLT */
} else if (vme->blt_mode == MVME_BLT_BLT32FIFO)
status = CAENVME_FIFOBLTWriteCycle(hvme, vme_addr, src, n_bytes, vme->am, cvD32, &n);
/* BLT */
else
status = CAENVME_BLTWriteCycle(hvme, vme_addr, src, n_bytes, vme->am, cvD32, &n);
/* D64 */
} else if (vme->dmode == MVME_DMODE_D64) {
/* FIFO MBLT */
if (vme->blt_mode == MVME_BLT_MBLT64FIFO)
status = CAENVME_FIFOMBLTWriteCycle(hvme, vme_addr, src, n_bytes, vme->am, &n);
/* MBLT */
else
status = CAENVME_MBLTWriteCycle(hvme, vme_addr, src, n_bytes, vme->am, &n);
}
if (status != cvSuccess)
n = 0;
return n;
}
/*------------------------------------------------------------------*/
int mvme_write_value(MVME_INTERFACE *vme, mvme_addr_t vme_addr, unsigned int value)
{
int status=0, n;
int hvme;
hvme = vme->handle;
if (vme->dmode == MVME_DMODE_D8)
n = 1;
else if (vme->dmode == MVME_DMODE_D16)
n = 2;
else
n = 4;
/* D8 */
if (vme->dmode == MVME_DMODE_D8)
status = CAENVME_WriteCycle(hvme, vme_addr, &value, vme->am, cvD8);
/* D16 */
else if (vme->dmode == MVME_DMODE_D16)
status = CAENVME_WriteCycle(hvme, vme_addr, &value, vme->am, cvD16);
/* D32 */
else if (vme->dmode == MVME_DMODE_D32)
status = CAENVME_WriteCycle(hvme, vme_addr, &value, vme->am, cvD32);
if (status != cvSuccess)
n = 0;
return n;
}
/*------------------------------------------------------------------*/
int mvme_read(MVME_INTERFACE *vme, void *dst, mvme_addr_t vme_addr, mvme_size_t n_bytes)
{
mvme_size_t i;
int status=0, n;
int hvme;
hvme = vme->handle;
n = 0;
/* D8 */
if ((vme->dmode == MVME_DMODE_D8) || (vme->blt_mode == MVME_BLT_NONE)) {
for (i=0 ; i<n_bytes ; i++)
status = CAENVME_ReadCycle(hvme, vme_addr, dst+i, vme->am, cvD8);
n = n_bytes;
/* D16 */
} else if (vme->dmode == MVME_DMODE_D16) {
/* normal I/O */
if (vme->blt_mode == MVME_BLT_NONE) {
for (i=0 ; i<(n_bytes>>1) ; i++)
status = CAENVME_ReadCycle(hvme, vme_addr, dst+(i<<1), vme->am, cvD16);
n = n_bytes;
/* FIFO BLT */
} else if ((vme->blt_mode == MVME_BLT_BLT32FIFO) || (vme->blt_mode == MVME_BLT_MBLT64FIFO))
status = CAENVME_FIFOBLTReadCycle(hvme, vme_addr, dst, n_bytes, vme->am, cvD16, &n);
/* BLT */
else
status = CAENVME_BLTReadCycle(hvme, vme_addr, dst, n_bytes, vme->am, cvD16, &n);
/* D32 */
} else if (vme->dmode == MVME_DMODE_D32) {
/* normal I/O */
if (vme->blt_mode == MVME_BLT_NONE) {
for (i=0 ; i<(n_bytes>>2) ; i++)
status = CAENVME_ReadCycle(hvme, vme_addr, dst+(i<<2), vme->am, cvD32);
n = n_bytes;
/* FIFO BLT */
} else if (vme->blt_mode == MVME_BLT_BLT32FIFO)
status = CAENVME_FIFOBLTReadCycle(hvme, vme_addr, dst, n_bytes, vme->am, cvD32, &n);
/* BLT */
else
status = CAENVME_BLTReadCycle(hvme, vme_addr, dst, n_bytes, vme->am, cvD32, &n);
/* D64 */
} else if (vme->dmode == MVME_DMODE_D64) {
/* FIFO MBLT */
if (vme->blt_mode == MVME_BLT_MBLT64FIFO)
status = CAENVME_FIFOMBLTReadCycle(hvme, vme_addr, dst, n_bytes, vme->am, &n);
/* MBLT */
else
status = CAENVME_MBLTReadCycle(hvme, vme_addr, dst, n_bytes, vme->am, &n);
}
if ((status != cvSuccess) && (status != cvBusError))
n = 0;
return n;
}
/*------------------------------------------------------------------*/
unsigned int mvme_read_value(MVME_INTERFACE *vme, mvme_addr_t vme_addr)
{
unsigned int data;
int status=0;
int hvme;
hvme = vme->handle;
data = 0;
/* D8 */
if (vme->dmode == MVME_DMODE_D8)
status = CAENVME_ReadCycle(hvme, vme_addr, &data, vme->am, cvD8);
/* D16 */
else if (vme->dmode == MVME_DMODE_D16)
status = CAENVME_ReadCycle(hvme, vme_addr, &data, vme->am, cvD16);
/* D32 */
else if (vme->dmode == MVME_DMODE_D32)
status = CAENVME_ReadCycle(hvme, vme_addr, &data, vme->am, cvD32);
return data;
}
/*------------------------------------------------------------------*/
int mvme_set_am(MVME_INTERFACE *vme, int am)
{
vme->am = am;
return MVME_SUCCESS;
}
/*------------------------------------------------------------------*/
int mvme_get_am(MVME_INTERFACE *vme, int *am)
{
*am = vme->am;
return MVME_SUCCESS;
}
/*------------------------------------------------------------------*/
int mvme_set_dmode(MVME_INTERFACE *vme, int dmode)
{
vme->dmode = dmode;
return MVME_SUCCESS;
}
/*------------------------------------------------------------------*/
int mvme_get_dmode(MVME_INTERFACE *vme, int *dmode)
{
*dmode = vme->dmode;
return MVME_SUCCESS;
}
/*------------------------------------------------------------------*/
int mvme_set_blt(MVME_INTERFACE *vme, int mode)
{
vme->blt_mode = mode;
return MVME_SUCCESS;
}
/*------------------------------------------------------------------*/
int mvme_get_blt(MVME_INTERFACE *vme, int *mode)
{
*mode = vme->blt_mode;
return MVME_SUCCESS;
}
/*------------------------------------------------------------------*/
... 326 more lines ...
|
| Attachment 4: v792n.h
|
/*********************************************************************
Name: v792n.h
Created by: Jimmy Ngai
Contents: V792N 16ch. QDC include
Based on v792.h by Pierre-Andre Amaudruz
$Id: $
*********************************************************************/
#ifndef V792N_INCLUDE_H
#define V792N_INCLUDE_H
#include <stdio.h>
#include <string.h>
#include "mvmestd.h"
#ifdef __cplusplus
extern "C" {
#endif
#define V792N_MAX_CHANNELS (DWORD) 16
#define V792N_REG_BASE (DWORD) (0x1000)
#define V792N_FIRM_REV (DWORD) (0x1000)
#define V792N_GEO_ADDR_RW (DWORD) (0x1002)
#define V792N_MCST_CBLT_RW (DWORD) (0x1004)
#define V792N_BIT_SET1_RW (DWORD) (0x1006)
#define V792N_BIT_CLEAR1_WO (DWORD) (0x1008)
#define V792N_SOFT_RESET (DWORD) (0x1<<7)
#define V792N_INT_LEVEL_WO (DWORD) (0x100A)
#define V792N_INT_VECTOR_WO (DWORD) (0x100C)
#define V792N_CSR1_RO (DWORD) (0x100E)
#define V792N_CR1_RW (DWORD) (0x1010)
#define V792N_ADER_H_RW (DWORD) (0x1012)
#define V792N_ADER_L_RW (DWORD) (0x1014)
#define V792N_SINGLE_RST_WO (DWORD) (0x1016)
#define V792N_MCST_CBLT_CTRL_RW (DWORD) (0x101A)
#define V792N_EVTRIG_REG_RW (DWORD) (0x1020)
#define V792N_CSR2_RO (DWORD) (0x1022)
#define V792N_EVT_CNT_L_RO (DWORD) (0x1024)
#define V792N_EVT_CNT_H_RO (DWORD) (0x1026)
#define V792N_INCR_EVT_WO (DWORD) (0x1028)
#define V792N_INCR_OFFSET_WO (DWORD) (0x102A)
#define V792N_LD_TEST_RW (DWORD) (0x102C)
#define V792N_DELAY_CLEAR_RW (DWORD) (0x102E)
#define V792N_FCLR_WIN_RW (DWORD) (0x102E)
#define V792N_BIT_SET2_RW (DWORD) (0x1032)
#define V792N_BIT_CLEAR2_WO (DWORD) (0x1034)
#define V792N_W_MEM_TEST_WO (DWORD) (0x1036)
#define V792N_MEM_TEST_WORD_H_WO (DWORD) (0x1038)
#define V792N_MEM_TEST_WORD_L_WO (DWORD) (0x103A)
#define V792N_CRATE_SEL_RW (DWORD) (0x103C)
#define V792N_TEST_EVENT_WO (DWORD) (0x103E)
#define V792N_EVT_CNT_RST_WO (DWORD) (0x1040)
#define V792N_IPED_RW (DWORD) (0x1060)
#define V792N_R_MEM_TEST_WO (DWORD) (0x1064)
#define V792N_SWCOMM_WO (DWORD) (0x1068)
#define V792N_SLIDECONST_RW (DWORD) (0x106A)
#define V792N_AAD_RO (DWORD) (0x1070)
#define V792N_BAD_RO (DWORD) (0x1072)
#define V792N_THRES_BASE (DWORD) (0x1080)
WORD v792n_Read16(MVME_INTERFACE *mvme, DWORD base, int offset);
void v792n_Write16(MVME_INTERFACE *mvme, DWORD base, int offset, WORD value);
DWORD v792n_Read32(MVME_INTERFACE *mvme, DWORD base, int offset);
void v792n_Write32(MVME_INTERFACE *mvme, DWORD base, int offset, DWORD value);
int v792n_DataReady(MVME_INTERFACE *mvme, DWORD base);
int v792n_isEvtReady(MVME_INTERFACE *mvme, DWORD base);
int v792n_isBusy(MVME_INTERFACE *mvme, DWORD base);
int v792n_EventRead(MVME_INTERFACE *mvme, DWORD base, DWORD *pdest, int *nentry);
int v792n_DataRead(MVME_INTERFACE *mvme, DWORD base, DWORD *pdest, int nentry);
void v792n_DataClear(MVME_INTERFACE *mvme, DWORD base);
void v792n_EvtCntRead(MVME_INTERFACE *mvme, DWORD base, DWORD *evtcnt);
void v792n_EvtCntReset(MVME_INTERFACE *mvme, DWORD base);
void v792n_IntSet(MVME_INTERFACE *mvme, DWORD base, int level, int vector);
void v792n_IntEnable(MVME_INTERFACE *mvme, DWORD base, int level);
void v792n_IntDisable(MVME_INTERFACE *mvme, DWORD base);
void v792n_EvtTriggerSet(MVME_INTERFACE *mvme, DWORD base, int count);
void v792n_SingleShotReset(MVME_INTERFACE *mvme, DWORD base);
void v792n_SoftReset(MVME_INTERFACE *mvme, DWORD base);
void v792n_Trigger(MVME_INTERFACE *mvme, DWORD base);
int v792n_ThresholdRead(MVME_INTERFACE *mvme, DWORD base, WORD *threshold);
int v792n_ThresholdWrite(MVME_INTERFACE *mvme, DWORD base, WORD *threshold);
int v792n_CSR1Read(MVME_INTERFACE *mvme, DWORD base);
int v792n_CSR2Read(MVME_INTERFACE *mvme, DWORD base);
int v792n_BitSet2Read(MVME_INTERFACE *mvme, DWORD base);
void v792n_BitSet2Set(MVME_INTERFACE *mvme, DWORD base, WORD pat);
void v792n_BitSet2Clear(MVME_INTERFACE *mvme, DWORD base, WORD pat);
WORD v792n_ControlRegister1Read(MVME_INTERFACE *mvme, DWORD base);
void v792n_ControlRegister1Write(MVME_INTERFACE *mvme, DWORD base, WORD pat);
void v792n_OnlineSet(MVME_INTERFACE *mvme, DWORD base);
void v792n_OfflineSet(MVME_INTERFACE *mvme, DWORD base);
void v792n_BlkEndEnable(MVME_INTERFACE *mvme, DWORD base);
void v792n_OverRangeEnable(MVME_INTERFACE *mvme, DWORD base);
void v792n_OverRangeDisable(MVME_INTERFACE *mvme, DWORD base);
void v792n_LowThEnable(MVME_INTERFACE *mvme, DWORD base);
void v792n_LowThDisable(MVME_INTERFACE *mvme, DWORD base);
void v792n_EmptyEnable(MVME_INTERFACE *mvme, DWORD base);
void v792n_CrateSet(MVME_INTERFACE *mvme, DWORD base, DWORD *evtcnt);
void v792n_DelayClearSet(MVME_INTERFACE *mvme, DWORD base, int delay);
int v792n_Setup(MVME_INTERFACE *mvme, DWORD base, int mode);
void v792n_Status(MVME_INTERFACE *mvme, DWORD base);
int v792n_isPresent(MVME_INTERFACE *mvme, DWORD base);
enum v792n_DataType {
v792n_typeMeasurement=0,
v792n_typeHeader =2,
v792n_typeFooter =4,
v792n_typeFiller =6
};
typedef union {
DWORD raw;
struct v792n_Entry {
unsigned adc:12; // bit0 here
unsigned ov:1;
unsigned un:1;
unsigned _pad_1:3;
unsigned channel:4;
unsigned _pad_2:3;
unsigned type:3;
unsigned geo:5;
} data ;
struct v792n_Header {
unsigned _pad_1:8; // bit0 here
unsigned cnt:6;
unsigned _pad_2:2;
unsigned crate:8;
unsigned type:3;
unsigned geo:5;
} header;
struct v792n_Footer {
unsigned evtCnt:24; // bit0 here
unsigned type:3;
unsigned geo:5;
} footer;
} v792n_Data;
typedef union {
DWORD raw;
struct {
unsigned DataReady:1; // bit0 here
unsigned GlobalDataReady:1;
unsigned Busy:1;
unsigned GlobalBusy:1;
unsigned Amnesia:1;
unsigned Purge:1;
unsigned TermOn:1;
unsigned TermOff:1;
unsigned EventReady:1; //bit 8 here
};
} v792n_StatusRegister1;
typedef union {
DWORD raw;
struct {
unsigned _pad_1:1; // bit0 here
unsigned BufferEmpty:1;
unsigned BufferFull:1;
unsigned _pad_2:1;
unsigned PB:4;
//unsigned DSEL0:1;
//unsigned DSEL1:1;
//unsigned CSEL0:1;
//unsigned CSEL1:1;
};
} v792n_StatusRegister2;
typedef union {
DWORD raw;
struct {
unsigned _pad_1:2;
unsigned BlkEnd:1;
unsigned _pad_2:1;
unsigned ProgReset:1;
unsigned BErr:1;
unsigned Align64:1;
};
} v792n_ControlRegister1;
typedef union {
DWORD raw;
struct {
unsigned MemTest:1;
unsigned OffLine:1;
unsigned ClearData:1;
unsigned OverRange:1;
unsigned LowThresh:1;
unsigned _pad_1:1;//bit5
unsigned TestAcq:1;
unsigned SLDEnable:1;
unsigned StepTH:1;
unsigned _pad_2:2;//bits 9-10
unsigned AutoIncr:1;
unsigned EmptyProg:1;
unsigned SlideSubEnable:1;
unsigned AllTrg:1;
};
} v792n_BitSet2Register;
void v792n_printEntry(const v792n_Data* v);
#ifdef __cplusplus
}
#endif
#endif // V792N_INCLUDE_H
/* emacs
* Local Variables:
* mode:C
* mode:font-lock
* tab-width: 8
* c-basic-offset: 2
* End:
*/
|
| Attachment 5: v792n.c
|
/*********************************************************************
Name: v792n.c
Created by: Jimmy Ngai
Contents: V792N 16ch. QDC
Based on v792.c by Pierre-Andre Amaudruz
$Id: $
*********************************************************************/
#include <stdio.h>
#include <string.h>
#include <signal.h>
#if defined(OS_LINUX)
#include <unistd.h>
#endif
#include "v792n.h"
WORD v792n_Read16(MVME_INTERFACE *mvme, DWORD base, int offset)
{
int cmode;
WORD data;
mvme_get_dmode(mvme, &cmode);
mvme_set_dmode(mvme, MVME_DMODE_D16);
data = mvme_read_value(mvme, base+offset);
mvme_set_dmode(mvme, cmode);
return data;
}
void v792n_Write16(MVME_INTERFACE *mvme, DWORD base, int offset, WORD value)
{
int cmode;
mvme_get_dmode(mvme, &cmode);
mvme_set_dmode(mvme, MVME_DMODE_D16);
mvme_write_value(mvme, base+offset, value);
mvme_set_dmode(mvme, cmode);
}
DWORD v792n_Read32(MVME_INTERFACE *mvme, DWORD base, int offset)
{
int cmode;
DWORD data;
mvme_get_dmode(mvme, &cmode);
mvme_set_dmode(mvme, MVME_DMODE_D32);
data = mvme_read_value(mvme, base+offset);
mvme_set_dmode(mvme, cmode);
return data;
}
void v792n_Write32(MVME_INTERFACE *mvme, DWORD base, int offset, DWORD value)
{
int cmode;
mvme_get_dmode(mvme, &cmode);
mvme_set_dmode(mvme, MVME_DMODE_D32);
mvme_write_value(mvme, base+offset, value);
mvme_set_dmode(mvme, cmode);
}
/*****************************************************************/
int v792n_DataReady(MVME_INTERFACE *mvme, DWORD base)
{
int data_ready, cmode;
mvme_get_dmode(mvme, &cmode);
mvme_set_dmode(mvme, MVME_DMODE_D16);
data_ready = mvme_read_value(mvme, base+V792N_CSR1_RO) & 0x1;
mvme_set_dmode(mvme, cmode);
return data_ready;
}
/*****************************************************************/
int v792n_isEvtReady(MVME_INTERFACE *mvme, DWORD base)
{
int csr;
csr = v792n_CSR1Read(mvme, base);
return (csr & 0x100);
}
/*****************************************************************/
int v792n_isBusy(MVME_INTERFACE *mvme, DWORD base)
{
int status, busy, timeout, cmode;
mvme_get_dmode(mvme, &cmode);
mvme_set_dmode(mvme, MVME_DMODE_D16);
timeout = 1000;
do {
status = mvme_read_value(mvme, base+V792N_CSR1_RO);
busy = status & 0x4;
timeout--;
} while (busy || timeout);
mvme_set_dmode(mvme, cmode);
return (busy != 0 ? 1 : 0);
}
/*****************************************************************/
/*
Read single event, return event length (number of entries)
*/
int v792n_EventRead(MVME_INTERFACE *mvme, DWORD base, DWORD *pdest, int *nentry)
{
#define USE_BLT_READ_2
#ifdef USE_SINGLE_READ
DWORD hdata;
int cmode;
mvme_get_dmode(mvme, &cmode);
mvme_set_dmode(mvme, MVME_DMODE_D32);
*nentry = 0;
if (v792n_DataReady(mvme, base)) {
do {
hdata = mvme_read_value(mvme, base);
} while (!(hdata & 0x02000000)); // skip up to the header
pdest[*nentry] = hdata;
*nentry += 1;
do {
pdest[*nentry] = mvme_read_value(mvme, base);
*nentry += 1;
} while (!(pdest[*nentry-1] & 0x04000000)); // copy until the trailer
nentry--;
}
mvme_set_dmode(mvme, cmode);
#endif // USE_SINGLE_READ
#ifdef USE_BLT_READ_1
DWORD hdata, data[V792N_MAX_CHANNELS+2];
int cam, cmode, cblt, cnt, i;
mvme_get_am(mvme, &cam);
mvme_get_dmode(mvme, &cmode);
mvme_get_blt(mvme, &cblt);
mvme_set_dmode(mvme, MVME_DMODE_D32);
*nentry = 0;
if (v792n_DataReady(mvme, base)) {
do {
hdata = mvme_read_value(mvme, base);
} while (!(hdata & 0x02000000)); // skip up to the header
mvme_set_am(mvme, MVME_AM_A32_SB);
mvme_set_blt(mvme, MVME_BLT_BLT32);
cnt = (hdata >> 8) & 0x3F;
mvme_read(mvme, data, base, (cnt+1)*4);
pdest[0] = hdata;
for (i=1;i<=cnt+1;i++)
pdest[i] = data[i-1];
*nentry = cnt + 2;
}
mvme_set_am(mvme, cam);
mvme_set_dmode(mvme, cmode);
mvme_set_blt(mvme, cblt);
#endif // USE_BLT_READ_1
#ifdef USE_BLT_READ_2
int cam, cmode, cblt, cnt;
mvme_get_am(mvme, &cam);
mvme_get_dmode(mvme, &cmode);
mvme_get_blt(mvme, &cblt);
mvme_set_dmode(mvme, MVME_DMODE_D32);
*nentry = 0;
// if (v792n_DataReady(mvme, base)) {
mvme_set_am(mvme, MVME_AM_A32_SB);
mvme_set_blt(mvme, MVME_BLT_BLT32);
mvme_read(mvme, pdest, base, (V792N_MAX_CHANNELS+2)*4);
cnt = (pdest[0] >> 8) & 0x3F;
*nentry = cnt + 2;
// }
mvme_set_am(mvme, cam);
mvme_set_dmode(mvme, cmode);
mvme_set_blt(mvme, cblt);
#endif //USE_BLT_READ_2
return *nentry;
}
/*****************************************************************/
/*
Read nentry of data from the data buffer
*/
int v792n_DataRead(MVME_INTERFACE *mvme, DWORD base, DWORD *pdest, int nentry)
{
int cmode, status;
mvme_get_dmode(mvme, &cmode);
mvme_set_dmode(mvme, MVME_DMODE_D32);
// nentry = 128;
if (v792n_DataReady(mvme, base)) {
status = mvme_read(mvme, pdest, base, nentry*4);
}
mvme_set_dmode(mvme, cmode);
return status;
}
/*****************************************************************/
void v792n_DataClear(MVME_INTERFACE *mvme, DWORD base)
{
int cmode;
mvme_get_dmode(mvme, &cmode);
mvme_set_dmode(mvme, MVME_DMODE_D16);
mvme_write_value(mvme, base+V792N_BIT_SET2_RW, 0x4);
mvme_write_value(mvme, base+V792N_BIT_CLEAR2_WO, 0x4);
mvme_set_dmode(mvme, cmode);
}
/*****************************************************************/
void v792n_EvtCntRead(MVME_INTERFACE *mvme, DWORD base, DWORD *evtcnt)
{
int cmode;
mvme_get_dmode(mvme, &cmode);
mvme_set_dmode(mvme, MVME_DMODE_D16);
*evtcnt = mvme_read_value(mvme, base+V792N_EVT_CNT_L_RO);
*evtcnt += (mvme_read_value(mvme, base+V792N_EVT_CNT_H_RO) << 16);
mvme_set_dmode(mvme, cmode);
}
/*****************************************************************/
void v792n_EvtCntReset(MVME_INTERFACE *mvme, DWORD base)
{
int cmode;
mvme_get_dmode(mvme, &cmode);
mvme_set_dmode(mvme, MVME_DMODE_D16);
mvme_write_value(mvme, base+V792N_EVT_CNT_RST_WO, 1);
mvme_set_dmode(mvme, cmode);
}
/*****************************************************************/
void v792n_IntSet(MVME_INTERFACE *mvme, DWORD base, int level, int vector)
{
int cmode;
mvme_get_dmode(mvme, &cmode);
mvme_set_dmode(mvme, MVME_DMODE_D16);
mvme_write_value(mvme, base+V792N_INT_VECTOR_WO, (vector & 0xFF));
mvme_write_value(mvme, base+V792N_INT_LEVEL_WO, (level & 0x7));
mvme_set_dmode(mvme, cmode);
}
/*****************************************************************/
void v792n_IntEnable(MVME_INTERFACE *mvme, DWORD base, int level)
{
int cmode;
mvme_get_dmode(mvme, &cmode);
mvme_set_dmode(mvme, MVME_DMODE_D16);
mvme_write_value(mvme, base+V792N_EVTRIG_REG_RW, (level & 0x1F));
/* Use the trigger buffer for int enable/disable
mvme_write_value(mvme, base+V792N_INT_LEVEL_WO, (level & 0x7));
*/
mvme_set_dmode(mvme, cmode);
}
/*****************************************************************/
void v792n_IntDisable(MVME_INTERFACE *mvme, DWORD base)
{
int cmode;
mvme_get_dmode(mvme, &cmode);
mvme_set_dmode(mvme, MVME_DMODE_D16);
mvme_write_value(mvme, base+V792N_EVTRIG_REG_RW, 0);
/* Use the trigger buffer for int enable/disable
Setting a level 0 reboot the VMIC !
mvme_write_value(mvme, base+V792N_INT_LEVEL_WO, 0);
*/
mvme_set_dmode(mvme, cmode);
}
/*****************************************************************/
void v792n_EvtTriggerSet(MVME_INTERFACE *mvme, DWORD base, int count)
{
int cmode;
mvme_get_dmode(mvme, &cmode);
mvme_set_dmode(mvme, MVME_DMODE_D16);
mvme_write_value(mvme, base+V792N_EVTRIG_REG_RW, (count & 0x1F));
mvme_set_dmode(mvme, cmode);
}
/*****************************************************************/
void v792n_SingleShotReset(MVME_INTERFACE *mvme, DWORD base)
{
int cmode;
mvme_get_dmode(mvme, &cmode);
mvme_set_dmode(mvme, MVME_DMODE_D16);
mvme_write_value(mvme, base+V792N_SINGLE_RST_WO, 1);
mvme_set_dmode(mvme, cmode);
}
/*****************************************************************/
... 409 more lines ...
|
|
762
|
24 May 2011 |
Jianglai Liu | Forum | simple example frontend for V1720 | Thanks all for the kind help. This did point me to the right direction. I was now able to make v1720.c as well as my MIDAS frontend (thanks to
Jimmy's example) talking to V1720, and read out the waveform bank.
However the readout values did not seem quite right. I fed in a PMT-like pulse of about 0.1 V and 50 ns wide, with an external trigger just in time.
However, the readout by both v1720.c stand-alone code, and my midas frontend seemed to be flat noise.
I tried to play with the post trigger value, as well as the DAC setting of V1720. None seemed to help.
BTW I tested my V1720 board functionality by using the CAEN windows software (CAENScope and WaveDump). They worked just fine.
Any suggestions? Attached is my modified v1720.c code.
| Pierre-Andre Amaudruz wrote: |
| Jianglai Liu wrote: | Hi,
Who has a good example of a frontend program using CAEN V1718 VME-USB bridge and
V1720 FADC? I am trying to set up the DAQ for such a simple system.
I put together a frontend which talks to the VME. However it gets stuck at
"Calibrating" in initialize_equipment().
I'd appreciate some help!
Thanks,
Jianglai |
Under the drivers/vme you can find code for the v1720.c (VME access) and ov1720.c
(A2818/A3818 PCIe optical link access). For testing the hardware, we use this code compiled and linked
with MAIN_ENABLE to confirm its functionality. You may want to do the same for your USB. Once this
is under control, the Midas frontend implementation using the same driver shouldn't give you trouble. |
|
| Attachment 1: v1720.c
|
/*********************************************************************
Name: v1720.c
Created by: Pierre-A. Amaudruz / K.Olchanski
Contents: V1720 8 ch. 12bit 250Msps
$Id: v1720.c 4728 2010-05-12 05:34:44Z svn $
*********************************************************************/
#include <stdio.h>
#include <stdint.h>
#include <string.h>
//#include "midas.h"
#include "v1720drv.h"
#include "mvmestd.h"
// Buffer organization map for number of samples
uint32_t V1720_NSAMPLES_MODE[11] = { (1<<20), (1<<19), (1<<18), (1<<17), (1<<16), (1<<15)
,(1<<14), (1<<13), (1<<12), (1<<11), (1<<10)};
/*****************************************************************/
/*
Read V1720 register value
*/
static uint32_t regRead(MVME_INTERFACE *mvme, uint32_t base, int offset)
{
mvme_set_am(mvme, MVME_AM_A32);
mvme_set_dmode(mvme, MVME_DMODE_D32);
return mvme_read_value(mvme, base + offset);
}
/*****************************************************************/
/*
Write V1720 register value
*/
static void regWrite(MVME_INTERFACE *mvme, uint32_t base, int offset, uint32_t value)
{
mvme_set_am(mvme, MVME_AM_A32);
mvme_set_dmode(mvme, MVME_DMODE_D32);
mvme_write_value(mvme, base + offset, value);
}
/*****************************************************************/
uint32_t v1720_RegisterRead(MVME_INTERFACE *mvme, uint32_t base, int offset)
{
return regRead(mvme, base, offset);
}
/*****************************************************************/
void v1720_RegisterWrite(MVME_INTERFACE *mvme, uint32_t base, int offset, uint32_t value)
{
regWrite(mvme, base, offset, value);
}
/*****************************************************************/
void v1720_Reset(MVME_INTERFACE *mvme, uint32_t base)
{
regWrite(mvme, base, V1720_SW_RESET, 0);
}
/*****************************************************************/
void v1720_TrgCtl(MVME_INTERFACE *mvme, uint32_t base, uint32_t reg, uint32_t mask)
{
regWrite(mvme, base, reg, mask);
}
/*****************************************************************/
void v1720_ChannelCtl(MVME_INTERFACE *mvme, uint32_t base, uint32_t reg, uint32_t mask)
{
regWrite(mvme, base, reg, mask);
}
/*****************************************************************/
void v1720_ChannelSet(MVME_INTERFACE *mvme, uint32_t base, uint32_t channel, uint32_t what, uint32_t that)
{
uint32_t reg, mask;
if (what == V1720_CHANNEL_THRESHOLD) mask = 0x0FFF;
if (what == V1720_CHANNEL_OUTHRESHOLD) mask = 0x0FFF;
if (what == V1720_CHANNEL_DAC) mask = 0xFFFF;
reg = what | (channel << 8);
printf("base:0x%x reg:0x%x, this:%x\n", base, reg, that);
regWrite(mvme, base, reg, (that & 0xFFF));
}
/*****************************************************************/
uint32_t v1720_ChannelGet(MVME_INTERFACE *mvme, uint32_t base, uint32_t channel, uint32_t what)
{
uint32_t reg, mask;
if (what == V1720_CHANNEL_THRESHOLD) mask = 0x0FFF;
if (what == V1720_CHANNEL_OUTHRESHOLD) mask = 0x0FFF;
if (what == V1720_CHANNEL_DAC) mask = 0xFFFF;
reg = what | (channel << 8);
return regRead(mvme, base, reg);
}
/*****************************************************************/
void v1720_ChannelThresholdSet(MVME_INTERFACE *mvme, uint32_t base, uint32_t channel, uint32_t threshold)
{
uint32_t reg;
reg = V1720_CHANNEL_THRESHOLD | (channel << 8);
printf("base:0x%x reg:0x%x, threshold:%x\n", base, reg, threshold);
regWrite(mvme, base, reg, (threshold & 0xFFF));
}
/*****************************************************************/
void v1720_ChannelOUThresholdSet(MVME_INTERFACE *mvme, uint32_t base, uint32_t channel, uint32_t threshold)
{
uint32_t reg;
reg = V1720_CHANNEL_OUTHRESHOLD | (channel << 8);
printf("base:0x%x reg:0x%x, outhreshold:%x\n", base, reg, threshold);
regWrite(mvme, base, reg, (threshold & 0xFFF));
}
/*****************************************************************/
void v1720_ChannelDACSet(MVME_INTERFACE *mvme, uint32_t base, uint32_t channel, uint32_t dac)
{
uint32_t reg;
reg = V1720_CHANNEL_DAC | (channel << 8);
printf("base:0x%x reg:0x%x, DAC:%x\n", base, reg, dac);
regWrite(mvme, base, reg, (dac & 0xFFFF));
}
/*****************************************************************/
int v1720_ChannelDACGet(MVME_INTERFACE *mvme, uint32_t base, uint32_t channel, uint32_t *dac)
{
uint32_t reg;
int status;
reg = V1720_CHANNEL_DAC | (channel << 8);
*dac = regRead(mvme, base, reg);
reg = V1720_CHANNEL_STATUS | (channel << 8);
status = regRead(mvme, base, reg);
return status;
}
/*****************************************************************/
void v1720_Align64Set(MVME_INTERFACE *mvme, uint32_t base)
{
regWrite(mvme, base, V1720_VME_CONTROL, V1720_ALIGN64);
}
/*****************************************************************/
void v1720_AcqCtl(MVME_INTERFACE *mvme, uint32_t base, uint32_t operation)
{
uint32_t reg;
reg = regRead(mvme, base, V1720_ACQUISITION_CONTROL);
switch (operation) {
case V1720_RUN_START:
regWrite(mvme, base, V1720_ACQUISITION_CONTROL, (reg | 0x4));
break;
case V1720_RUN_STOP:
regWrite(mvme, base, V1720_ACQUISITION_CONTROL, (reg & ~(0x4)));
break;
case V1720_REGISTER_RUN_MODE:
regWrite(mvme, base, V1720_ACQUISITION_CONTROL, (reg & ~(0x3)));
break;
case V1720_SIN_RUN_MODE:
regWrite(mvme, base, V1720_ACQUISITION_CONTROL, (reg | 0x01));
break;
case V1720_SIN_GATE_RUN_MODE:
regWrite(mvme, base, V1720_ACQUISITION_CONTROL, (reg | 0x02));
break;
case V1720_MULTI_BOARD_SYNC_MODE:
regWrite(mvme, base, V1720_ACQUISITION_CONTROL, (reg | 0x03));
break;
case V1720_COUNT_ACCEPTED_TRIGGER:
regWrite(mvme, base, V1720_ACQUISITION_CONTROL, (reg | 0x08));
break;
case V1720_COUNT_ALL_TRIGGER:
regWrite(mvme, base, V1720_ACQUISITION_CONTROL, (reg & ~(0x08)));
break;
default:
break;
}
}
/*****************************************************************/
void v1720_info(MVME_INTERFACE *mvme, uint32_t base, int *nchannels, uint32_t *n32word)
{
int i, chanmask;
// Evaluate the event size
// Number of samples per channels
*n32word = V1720_NSAMPLES_MODE[regRead(mvme, base, V1720_BUFFER_ORGANIZATION)];
// times the number of active channels
chanmask = 0xff & regRead(mvme, base, V1720_CHANNEL_EN_MASK);
*nchannels = 0;
for (i=0;i<8;i++) {
if (chanmask & (1<<i))
*nchannels += 1;
}
*n32word *= *nchannels;
*n32word /= 2; // 2 samples per 32bit word
*n32word += 4; // Headers
}
/*****************************************************************/
uint32_t v1720_BufferOccupancy(MVME_INTERFACE *mvme, uint32_t base, uint32_t channel)
{
uint32_t reg;
reg = V1720_BUFFER_OCCUPANCY + (channel<<16);
return regRead(mvme, base, reg);
}
/*****************************************************************/
uint32_t v1720_BufferFree(MVME_INTERFACE *mvme, uint32_t base, int nbuffer)
{
int mode;
mode = regRead(mvme, base, V1720_BUFFER_ORGANIZATION);
if (nbuffer <= (1<< mode) ) {
regWrite(mvme, base, V1720_BUFFER_FREE, nbuffer);
return mode;
} else
return mode;
}
/*****************************************************************/
uint32_t v1720_BufferFreeRead(MVME_INTERFACE *mvme, uint32_t base)
{
return regRead(mvme, base, V1720_BUFFER_FREE);
}
/*****************************************************************/
uint32_t v1720_DataRead(MVME_INTERFACE *mvme, uint32_t base, uint32_t *pdata, uint32_t n32w)
{
uint32_t i;
for (i=0;i<n32w;i++) {
*pdata = regRead(mvme, base, V1720_EVENT_READOUT_BUFFER);
if (*pdata != 0xffffffff)
pdata++;
else
break;
}
return i;
}
/********************************************************************/
/** v1720_DataBlockRead
Read N entries (32bit)
@param mvme vme structure
@param base base address
@param pdest Destination pointer
@return nentry
*/
uint32_t v1720_DataBlockRead(MVME_INTERFACE *mvme, uint32_t base, uint32_t *pdest, uint32_t *nentry)
{
int status;
mvme_set_am( mvme, MVME_AM_A32);
mvme_set_dmode( mvme, MVME_DMODE_D32);
//mvme_set_blt( mvme, MVME_BLT_MBLT64);
//mvme_set_blt( mvme, MVME_BLT_NONE);
mvme_set_blt(mvme, MVME_BLT_BLT32);
//mvme_set_blt( mvme, 0);
// Transfer in MBLT64 (8bytes), nentry is in 32bits(VF48)
// *nentry * 8 / 2
status = mvme_read(mvme, pdest, base+V1720_EVENT_READOUT_BUFFER, 4);
//printf("status = %d\n",status);
if (status != MVME_SUCCESS)
return 0;
return (*nentry);
}
/*****************************************************************/
void v1720_Status(MVME_INTERFACE *mvme, uint32_t base)
{
printf("================================================\n");
printf("V1720 at A32 0x%x\n", (int)base);
printf("Board ID : 0x%x\n", regRead(mvme, base, V1720_BOARD_ID));
printf("Board Info : 0x%x\n", regRead(mvme, base, V1720_BOARD_INFO));
printf("Acquisition status : 0x%8.8x\n", regRead(mvme, base, V1720_ACQUISITION_STATUS));
printf("================================================\n");
}
/*****************************************************************/
/**
Sets all the necessary paramters for a given configuration.
The configuration is provided by the mode argument.
Add your own configuration in the case statement. Let me know
your setting if you want to include it in the distribution.
- <b>Mode 1</b> :
@param *mvme VME structure
@param base Module base address
@param mode Configuration mode number
@return 0: OK. -1: Bad
*/
... 169 more lines ...
|
|
825
|
10 Aug 2012 |
Carl Blaksley | Forum | simple example frontend for V1720 |
| Jimmy Ngai wrote: |
| Jianglai Liu wrote: | Hi,
Who has a good example of a frontend program using CAEN V1718 VME-USB bridge and
V1720 FADC? I am trying to set up the DAQ for such a simple system.
I put together a frontend which talks to the VME. However it gets stuck at
"Calibrating" in initialize_equipment().
I'd appreciate some help!
Thanks,
Jianglai |
Hi Jianglai,
I don't have an exmaple of using V1718 with V1720, but I have been using V1718 with V792N for a long time.
You may find in the attachment an example frontend program and my drivers for V1718 and V792N written in MVMESTD format. They have to be linked with the CAENVMELib library and other essential MIDAS stuffs.
Regards,
Jimmy |
Jimmy,
How exactly did you link the CAENVMElib with your frontend? That is the part which I can not seem to replicate using your example frontend!
Thanks,
-Carl |
|
826
|
12 Aug 2012 |
Jimmy Ngai | Forum | simple example frontend for V1720 |
| Carl Blaksley wrote: |
| Jimmy Ngai wrote: |
| Jianglai Liu wrote: | Hi,
Who has a good example of a frontend program using CAEN V1718 VME-USB bridge and
V1720 FADC? I am trying to set up the DAQ for such a simple system.
I put together a frontend which talks to the VME. However it gets stuck at
"Calibrating" in initialize_equipment().
I'd appreciate some help!
Thanks,
Jianglai |
Hi Jianglai,
I don't have an exmaple of using V1718 with V1720, but I have been using V1718 with V792N for a long time.
You may find in the attachment an example frontend program and my drivers for V1718 and V792N written in MVMESTD format. They have to be linked with the CAENVMELib library and other essential MIDAS stuffs.
Regards,
Jimmy |
Jimmy,
How exactly did you link the CAENVMElib with your frontend? That is the part which I can not seem to replicate using your example frontend!
Thanks,
-Carl |
Hi Carl,
Attached is a cut-down version of my original Makefile just for demonstrating how to link the CAENVMElib. I didn't test it for bugs. Please make sure the libCAENVME.so is in your library path.
Jimmy |
| Attachment 1: Makefile
|
#####################################################################
#
# Name: Makefile
# Created by: Stefan Ritt
# Modified by: Jimmy Ngai
#
# Date: July 20, 2012
#
# Contents: Makefile for MIDAS example frontend and analyzer
#
# $Id: Makefile 3203 2006-07-31 21:39:02Z ritt $
#
#####################################################################
#
#--------------------------------------------------------------------
# The MIDASSYS should be defined prior the use of this Makefile
ifndef MIDASSYS
missmidas::
@echo "...";
@echo "Missing definition of environment variable 'MIDASSYS' !";
@echo "...";
endif
# get OS type from shell
OSTYPE = $(shell uname)
#--------------------------------------------------------------------
# The following lines contain specific switches for different UNIX
# systems. Find the one which matches your OS and outcomment the
# lines below.
#-----------------------------------------
# This is for Linux
ifeq ($(OSTYPE),Linux)
OSTYPE = linux
endif
ifeq ($(OSTYPE),linux)
OS_DIR = linux
OSFLAGS = -DOS_LINUX -DLINUX -DUNIX -Dextname
CFLAGS = -g -O2 -Wall -Wno-write-strings
# add to compile in 32-bit mode
# OSFLAGS += -m32
LIBS = -lm -lz -lutil -lnsl -lpthread
endif
#-----------------------
# MacOSX/Darwin is just a funny Linux
#
ifeq ($(OSTYPE),Darwin)
OSTYPE = darwin
endif
ifeq ($(OSTYPE),darwin)
OS_DIR = darwin
FF = cc
OSFLAGS = -DOS_LINUX -DLINUX -DOS_DARWIN -DUNIX -DHAVE_STRLCPY -DAbsoftUNIXFortran -fPIC -Wno-unused-function
LIBS = -lpthread
SPECIFIC_OS_PRG = $(BIN_DIR)/mlxspeaker
NEED_STRLCPY=
NEED_RANLIB=1
NEED_SHLIB=
NEED_RPATH=
endif
#-----------------------------------------
# ROOT flags and libs
#
ifdef ROOTSYS
ROOTCFLAGS := $(shell $(ROOTSYS)/bin/root-config --cflags)
ROOTCFLAGS += -DHAVE_ROOT -DUSE_ROOT
ROOTLIBS := $(shell $(ROOTSYS)/bin/root-config --libs) -Wl,-rpath,$(ROOTSYS)/lib
ROOTLIBS += -lThread
else
missroot:
@echo "...";
@echo "Missing definition of environment variable 'ROOTSYS' !";
@echo "...";
endif
#-------------------------------------------------------------------
# The following lines define directories. Adjust if necessary
#
INC_DIR = $(MIDASSYS)/include
LIB_DIR = $(MIDASSYS)/$(OS_DIR)/lib
SRC_DIR = $(MIDASSYS)/src
DRV_DIR = ./drivers
MOD_DIR = ./modules
#-------------------------------------------------------------------
# List of analyzer modules
#
MODULES = adccalib.o adcsum.o scaler.o
#-------------------------------------------------------------------
# Drivers needed by the frontend program
#
TRFE_DRIVERS = v1718.o v792n.o
TRFE_LIBS = -lCAENVME
#-------------------------------------------------------------------
# Frontend code name defaulted to frontend in this example.
# comment out the line and run your own frontend as follow:
# gmake UFE=my_frontend
#
TRFE = trfrontend
####################################################################
# Lines below here should not be edited
####################################################################
# MIDAS library
LIB = $(LIB_DIR)/libmidas.a
# compiler
CC = gcc
CXX = g++
CFLAGS += -g -I. -I$(INC_DIR) -I$(DRV_DIR)
CFLAGS += -I$(DRV_DIR)/vme
CFLAGS += -I$(DRV_DIR)/vme/CAENVMElib/include
LDFLAGS +=
all: $(TRFE) analyzer
noenv: all
$(TRFE): $(LIB) $(LIB_DIR)/mfe.o $(TRFE_DRIVERS) $(TRFE).c $(SRC_DIR)/cnaf_callback.c
$(CC) $(CFLAGS) $(OSFLAGS) -o $(TRFE) $(TRFE).c \
$(SRC_DIR)/cnaf_callback.c $(TRFE_DRIVERS) $(LIB_DIR)/mfe.o $(LIB) \
$(LDFEFLAGS) $(LIBS) $(TRFE_LIBS)
%.o: $(DRV_DIR)/vme/%.c
$(CC) $(CFLAGS) $(OSFLAGS) -o $@ -c $<
analyzer: $(LIB) $(LIB_DIR)/rmana.o analyzer.o $(MODULES)
$(CXX) $(CFLAGS) -o $@ $(LIB_DIR)/rmana.o analyzer.o $(MODULES) \
$(LIB) $(LDFLAGS) $(ROOTLIBS) $(LIBS) $(ANA_LIBS)
%.o: %.c experim.h
$(CXX) $(USERFLAGS) $(ROOTCFLAGS) $(CFLAGS) $(OSFLAGS) -o $@ -c $<
%.o: $(MOD_DIR)/%.c experim.h
$(CXX) $(USERFLAGS) $(ROOTCFLAGS) $(CFLAGS) $(OSFLAGS) -o $@ -c $<
clean::
rm -rf *.o *~ \#*
#end file
|
|
158
|
13 Oct 2004 |
Konstantin Olchanski | Bug Report | silly odbedit "rename Display xxx/yyy" | odbedit command "rename Display xxx/yyy" creates a key named "xxx/yyy" (yes,
with a slash in the name) and this key cannot be deleted or renamed...
K.O. |
|
159
|
13 Oct 2004 |
Stefan Ritt | Bug Report | silly odbedit "rename Display xxx/yyy" | > odbedit command "rename Display xxx/yyy" creates a key named "xxx/yyy" (yes,
> with a slash in the name) and this key cannot be deleted or renamed...
> K.O.
"rename" is "rename", not "mv" under Unix. If you want this functionality, put it
in and don't complain! |
|
2115
|
02 Mar 2021 |
Konstantin Olchanski | Info | shortest possible sleep | since I am implementing a polled equipment, I was curious what is the smallest possible sleep time on current computers.
in current UNIX, there are 2 system calls available for sleeping: select() (with microsecond granularity) and nanosleep() (with nanosecond granularity).
So I wrote a little test program to check it out (progs/test_sleep).
First, Linux result using select(). Typical run on AMD 3700X CPU (4.1 GHz turbo boost) with Ubuntu LTS 20, linux kernel 5.8:
daq13:midas$ ./bin/test_sleep
sleep 10 loops, 0.100000 sec per loop, 1.000000 sec total, 1003368.855 usec actual, 100336.885 usec actual per loop, oversleep 336.885 usec, 0.3%
sleep 100 loops, 0.010000 sec per loop, 1.000000 sec total, 1008512.020 usec actual, 10085.120 usec actual per loop, oversleep 85.120 usec, 0.9%
sleep 1000 loops, 0.001000 sec per loop, 1.000000 sec total, 1062137.842 usec actual, 1062.138 usec actual per loop, oversleep 62.138 usec, 6.2%
sleep 10000 loops, 0.000100 sec per loop, 1.000000 sec total, 1528650.999 usec actual, 152.865 usec actual per loop, oversleep 52.865 usec, 52.9%
sleep 99999 loops, 0.000010 sec per loop, 0.999990 sec total, 6250898.123 usec actual, 62.510 usec actual per loop, oversleep 52.510 usec, 525.1%
sleep 1000000 loops, 0.000001 sec per loop, 1.000000 sec total, 54056918.144 usec actual, 54.057 usec actual per loop, oversleep 53.057 usec, 5305.7%
sleep 1000000 loops, 0.000000 sec per loop, 0.100000 sec total, 210875.988 usec actual, 0.211 usec actual per loop, oversleep 0.111 usec, 110.9%
sleep 1000000 loops, 0.000000 sec per loop, 0.010000 sec total, 204804.897 usec actual, 0.205 usec actual per loop, oversleep 0.195 usec, 1948.0%
daq13:midas$
How to read this:
First line is 10 sleeps of 100 ms, for a total of 1 sec. this actually sleeps for a bit longer,
average over-sleep is 300 usec out of 100 ms is 0.3%.
Next few lines use progressively shorter sleep, 10 ms, 1 ms and 0.1 ms. over-sleep is consistently around 50-60 usec,
which I conclude to be this linux sleep granularity.
Last two lines try sleep for 0.1 usec and 0.01 usec, resulting in a zero-time sleep of select(),
so we just measure the average time cost of a linux syscall, around 200 ns in this machine.
Going to different machines:
Intel E-2236 (4.8 GHz tutboboost), Ubuntu LTS 20, linux kernel 5.8: over-sleep is 60 usec, zero-sleep is 400 ns.
Intel E-2226G (same, see arc.intel.com), CentOS-7, linux kernel 3.10: over-sleep is 60 usec, zero-sleep is 600 ns.
VME processor (2 GHz Intel T7400), Ubuntu 20, linux kernel 5.8: over-sleep is 60 usec, zero-sleep is 1700 ns.
This is pretty consistent, select() over-sleep is 60 usec on all hardware, zero-sleep tracks CPU GHz ratings.
Next, MacOS result, MacBookAir2020, MacOS 10.15.7, CPU 1.2 GHz i7-1060G7:
4ed0:midas olchansk$ ./bin/test_sleep
sleep 10 loops, 0.100000 sec per loop, 1.000000 sec total, 1031108.856 usec actual, 103110.886 usec actual per loop, oversleep 3110.886 usec, 3.1%
sleep 100 loops, 0.010000 sec per loop, 1.000000 sec total, 1091104.984 usec actual, 10911.050 usec actual per loop, oversleep 911.050 usec, 9.1%
sleep 1000 loops, 0.001000 sec per loop, 1.000000 sec total, 1270800.829 usec actual, 1270.801 usec actual per loop, oversleep 270.801 usec, 27.1%
sleep 10000 loops, 0.000100 sec per loop, 1.000000 sec total, 1370345.116 usec actual, 137.035 usec actual per loop, oversleep 37.035 usec, 37.0%
sleep 99999 loops, 0.000010 sec per loop, 0.999990 sec total, 1706473.112 usec actual, 17.065 usec actual per loop, oversleep 7.065 usec, 70.6%
sleep 1000000 loops, 0.000001 sec per loop, 1.000000 sec total, 5150341.034 usec actual, 5.150 usec actual per loop, oversleep 4.150 usec, 415.0%
sleep 1000000 loops, 0.000000 sec per loop, 0.100000 sec total, 595654.011 usec actual, 0.596 usec actual per loop, oversleep 0.496 usec, 495.7%
sleep 1000000 loops, 0.000000 sec per loop, 0.010000 sec total, 591560.125 usec actual, 0.592 usec actual per loop, oversleep 0.582 usec, 5815.6%
4ed0:midas olchansk$
things are quite different here, OS is Mach microkernel with an oldish FreeBSD UNIX single-server (from NextSTEP),
so the sleep granularity is different, better than linux. zero-sleep still measures the syscall time, 600 ns on this machine.
Next we measure the same using the nansleep() syscall.
daq13:midas$ ./bin/test_sleep
sleep 10 loops, 0.100000 sec per loop, 1.000000 sec total, 1004133.940 usec actual, 100413.394 usec actual per loop, oversleep 413.394 usec, 0.4%
sleep 100 loops, 0.010000 sec per loop, 1.000000 sec total, 1046117.067 usec actual, 10461.171 usec actual per loop, oversleep 461.171 usec, 4.6%
sleep 1000 loops, 0.001000 sec per loop, 1.000000 sec total, 1096894.979 usec actual, 1096.895 usec actual per loop, oversleep 96.895 usec, 9.7%
sleep 10000 loops, 0.000100 sec per loop, 1.000000 sec total, 1526744.843 usec actual, 152.674 usec actual per loop, oversleep 52.674 usec, 52.7%
sleep 99999 loops, 0.000010 sec per loop, 0.999990 sec total, 6250154.018 usec actual, 62.502 usec actual per loop, oversleep 52.502 usec, 525.0%
sleep 1000000 loops, 0.000001 sec per loop, 1.000000 sec total, 53344123.125 usec actual, 53.344 usec actual per loop, oversleep 52.344 usec, 5234.4%
sleep 1000000 loops, 0.000000 sec per loop, 0.100000 sec total, 52641665.936 usec actual, 52.642 usec actual per loop, oversleep 52.542 usec, 52541.7%
sleep 1000000 loops, 0.000000 sec per loop, 0.010000 sec total, 52637501.001 usec actual, 52.638 usec actual per loop, oversleep 52.628 usec, 526275.0%
daq13:midas$
Here everything is simple. sleep longer than 1000 usec works the same as select(), sleep for shorter than 100 usec sleeps for 52 usec, regardless of what
we ask for.
MacOS does no better, long sleeps are same as select(), sleeps is 1 usec or less sleep for too long. no improvement over select().
4ed0:midas olchansk$ ./bin/test_sleep
sleep 10 loops, 0.100000 sec per loop, 1.000000 sec total, 1023327.827 usec actual, 102332.783 usec actual per loop, oversleep 2332.783 usec, 2.3%
sleep 100 loops, 0.010000 sec per loop, 1.000000 sec total, 1130330.086 usec actual, 11303.301 usec actual per loop, oversleep 1303.301 usec, 13.0%
sleep 1000 loops, 0.001000 sec per loop, 1.000000 sec total, 1333846.807 usec actual, 1333.847 usec actual per loop, oversleep 333.847 usec, 33.4%
sleep 10000 loops, 0.000100 sec per loop, 1.000000 sec total, 1402330.160 usec actual, 140.233 usec actual per loop, oversleep 40.233 usec, 40.2%
sleep 99999 loops, 0.000010 sec per loop, 0.999990 sec total, 2034706.831 usec actual, 20.347 usec actual per loop, oversleep 10.347 usec, 103.5%
sleep 1000000 loops, 0.000001 sec per loop, 1.000000 sec total, 6646192.074 usec actual, 6.646 usec actual per loop, oversleep 5.646 usec, 564.6%
sleep 1000000 loops, 0.000000 sec per loop, 0.100000 sec total, 7556284.189 usec actual, 7.556 usec actual per loop, oversleep 7.456 usec, 7456.3%
sleep 1000000 loops, 0.000000 sec per loop, 0.010000 sec total, 15720005.035 usec actual, 15.720 usec actual per loop, oversleep 15.710 usec, 157100.1%
4ed0:midas olchansk$
On Linux, strace tells us that the actual syscall behind nanosleep() is this:
clock_nanosleep(CLOCK_REALTIME, 0, {tv_sec=0, tv_nsec=10000}, 0x7fffc159e200) = 0
Let's try it directly... result is the same.
Let's try it with CLOCK_MONOTONIC... result is the same.
The man page of clock_nanosleep() specifies that this syscall always suspends the calling thread,
so what we see here is the Linux scheduler tick size.
Bottom line.
On current linux, shortest sleep is around 100 usec both select() and nanosleep().
On MacOS, shortest sleep is down to 5 usec using select(), but I cannot tell if CPU sleeps or busy-loops.
select() is still the best syscall for sleeping.
K.O. |
|
2116
|
02 Mar 2021 |
Stefan Ritt | Info | shortest possible sleep | Why do you need that? Periodic equipment typically runs ever ten seconds or so, meaning one can do this easily in a scheduler.
For polled equipment, you don't want to sleep at all. Because if you sleep, you might miss an event. That's why I put my poll in mfe.c into a for() loop. No
sleep, maximum polling rate. I just double checked on my macbook air.
- If poll is always false (no event available), the loop executes 50M times in 100ms (calibrated during startup of the frontend). That means one iteration
takes 2ns (!). So if an event occurs, the readout is started with a 2ns overhead. No sleep can beat that. In a real world application, one has to add of course
the VME access or so to poll for the event.
- If poll is always true, the framework generates about 700k events each second (returning jus a few bytes of event data).
So if one adds any sleep here, things can get only worse, so I don't see the point for that. Of course polling eats one kernel at 100%, but these days every
CPU has more than one, even my 800 MHz Xilinx embedded ARM CPU (Zynq).
Best,
Stefan |
|
2117
|
03 Mar 2021 |
Konstantin Olchanski | Info | shortest possible sleep | > Why do you need that?
UNIX/POSIX advertises functions for sleeping in microseconds and nanoseconds,
for sure it is interesting to know what they actually do and what happens
when you ask them to sleep for 1 microsecond or 1 nanosecond.
To sleep or not to sleep that is a question.
But if I do decide to sleep, and I call the sleep function, I want to know what actually happens.
Now I do and I share it with all.
On current Linux, shortest sleep is around 60 usec. select() with sleep
shorter than that will not sleep at all, nanosleep() will always sleep for
the shortest amount.
P.S. For fans of interrupts ("because they are fast"), sleep waiting for interrupt
probably has same latency/granularity as above (60 usec), so if I drive a DMA engine
and I except the DMA transfer to complete under 60 usec, I should use a busy loop
to poll the "DMA done" bit instead of going to sleep and wait for the DMA interrupt.
K.O. |
|
2790
|
05 Jul 2024 |
Joseph McKenna | Suggestion | shared pointers for more flexible memory managment of the analysis 'flow' and TMEvent | > Hi all, I hope this is the right place to post two pull requests, if not, please let me know where I should be submitting them
>
> Both are fairly small changes, please see them listed below (more details written on the PRs themselves)
>
>
> - Enable ROOT's thread safety when running in multithreaded mode
>
> This helps avoid users having to write their call to a global thread lock when calling ->Fill() on ROOT histograms and Trees
> https://bitbucket.org/tmidas/manalyzer/pull-requests/5
>
>
> - Add command argument to specify an IP of the root HTTP server to bind to
>
> This was a problem I painted around when at ALPHA (quickly hardcoding the right external IP address into the local build. Obviously a bad habit)
> https://bitbucket.org/tmidas/manalyzer/pull-requests/6
Further to the pull manalyzer pull requests, I have another feature I would like to add. Took a little longer to test than planned... here I present an effort to use smart pointers to manage the lifetime of TMEvents and TAFlow.
I will be interested to discuss the implications of this pull request (its possible to return to previous 'raw' pointers via a cmake toggle)
https://bitbucket.org/tmidas/manalyzer/pull-requests/8 |
|
101
|
20 Nov 2003 |
Konstantin Olchanski | | set-uid-root midas programs | I see that MIDAS installs several set-uid-root programs into /usr/local/bin.
In this age and time of evil computer hackers, this is not a good idea and
we should Do Something (TM) about it. Here is my risk assessment:
[olchansk@midtis06 midas]$ ls -l /usr/local/bin | grep wsr
-rwsr-sr-x 1 root root 25811 Nov 20 09:27 dio
-rwsr-sr-x 1 root root 344553 Nov 20 09:27 mhttpd
-rwsr-sr-x 1 root root 70736 Nov 20 09:27 webpaw
dio- is required to be setuid-root to gain I/O permissions. I looked at it a
few times, and it is probably safe, but I would like to get a second
opinion. Stephan, can you should it to your local security geeks?
mhttpd- definitely unsafe. It has more buffer overflows than I can shake a
stick at. Why is it suid-root anyway?
webpaw- what is it?!?
K.O. |
|
102
|
20 Nov 2003 |
Stefan Ritt | | set-uid-root midas programs | > dio- is required to be setuid-root to gain I/O permissions. I looked at it a
> few times, and it is probably safe, but I would like to get a second
> opinion. Stephan, can you should it to your local security geeks?
>
> mhttpd- definitely unsafe. It has more buffer overflows than I can shake a
> stick at. Why is it suid-root anyway?
>
> webpaw- what is it?!?
dio was written by Pierre.
mhttpd and webpaw both are web servers. webpaw is used to display PAW
pictures over the web. If you run these programs at a port <1024, and most
people do run them at port 80 (at least at PSI), they need to be setuid-root.
Unless you know a better way to do that... |
|
859
|
11 Feb 2013 |
Wes Gohn | Forum | send_tcp error | I am getting a series of errors from MIDAS that I do not understand, so I hope
someone can help me figure this out.
I am attempting to run many frontends on one machine. I can run 8 with no
problem, but if I try to add a 9th I get errors relating to send_tcp.
I have tried adjusting the max event sizes and buffer sizes, but it has not
resolved the problem. I also tried adjusting the data rates and the total data
volume going through each frontend, but there was no change. And as far as I can
tell I am not up against any hardware limits.
The errors are repeated continuously while a run is going. The three errors I
get are:
16:45:22 [FakeData09,ERROR] [midas.c:9958:rpc_client_call,ERROR] send_tcp() failed
16:45:22 [FakeData09,ERROR] [frontend_rpc.c:191:rpc_call,ERROR] No RPC to master
16:45:22 [FakeData09,ERROR] [system.c:4166:send_tcp,ERROR]
send(socket=9,size=16) returned -1, errno: 32 (Broken pipe)
If you have any suggestions of how I can debug this, please let me know. Thanks! |
|
860
|
11 Feb 2013 |
Stefan Ritt | Forum | send_tcp error | > I am getting a series of errors from MIDAS that I do not understand, so I hope
> someone can help me figure this out.
>
> I am attempting to run many frontends on one machine. I can run 8 with no
> problem, but if I try to add a 9th I get errors relating to send_tcp.
>
> I have tried adjusting the max event sizes and buffer sizes, but it has not
> resolved the problem. I also tried adjusting the data rates and the total data
> volume going through each frontend, but there was no change. And as far as I can
> tell I am not up against any hardware limits.
>
> The errors are repeated continuously while a run is going. The three errors I
> get are:
>
> 16:45:22 [FakeData09,ERROR] [midas.c:9958:rpc_client_call,ERROR] send_tcp() failed
> 16:45:22 [FakeData09,ERROR] [frontend_rpc.c:191:rpc_call,ERROR] No RPC to master
> 16:45:22 [FakeData09,ERROR] [system.c:4166:send_tcp,ERROR]
> send(socket=9,size=16) returned -1, errno: 32 (Broken pipe)
>
> If you have any suggestions of how I can debug this, please let me know. Thanks!
Can you tell me
- why you need 9 frontends
- what kind of data your frontends produce
- how your event builder looks like and how you assemble the fragments
- what messages/errors you see when you run odbedit BEFORE the crash
/Stefan |
|
861
|
11 Feb 2013 |
Wes Gohn | Forum | send_tcp error | > > I am getting a series of errors from MIDAS that I do not understand, so I hope
> > someone can help me figure this out.
> >
> > I am attempting to run many frontends on one machine. I can run 8 with no
> > problem, but if I try to add a 9th I get errors relating to send_tcp.
> >
> > I have tried adjusting the max event sizes and buffer sizes, but it has not
> > resolved the problem. I also tried adjusting the data rates and the total data
> > volume going through each frontend, but there was no change. And as far as I can
> > tell I am not up against any hardware limits.
> >
> > The errors are repeated continuously while a run is going. The three errors I
> > get are:
> >
> > 16:45:22 [FakeData09,ERROR] [midas.c:9958:rpc_client_call,ERROR] send_tcp() failed
> > 16:45:22 [FakeData09,ERROR] [frontend_rpc.c:191:rpc_call,ERROR] No RPC to master
> > 16:45:22 [FakeData09,ERROR] [system.c:4166:send_tcp,ERROR]
> > send(socket=9,size=16) returned -1, errno: 32 (Broken pipe)
> >
> > If you have any suggestions of how I can debug this, please let me know. Thanks!
>
> Can you tell me
>
> - why you need 9 frontends
> - what kind of data your frontends produce
> - how your event builder looks like and how you assemble the fragments
> - what messages/errors you see when you run odbedit BEFORE the crash
>
> /Stefan
Our experiment will need 24 frontends that will each run on its own machine. For now we
want to run 24 "fake" frontends on one machine for testing purposes. 9 is the limit
where it stops working properly.
We have a pulser that is giving us periodic data at a constant rate. We have a master
frontend running on a different PC in interrupt mode that assembles the events, and then
N "FakeData" frontends running in polled mode on a single PC.
We do have an event builder, but we get these errors whether the event builder is
running or not.
At the start of a run, I see the following messages:
[mtransition,INFO] Run #21 started
Sat Feb 9 16:14:57 2013 [FakeData09,ERROR] [system.c:4166:send_tcp,ERROR]
send(socket=9,size=16) returned -1, errno: 104 (Connection reset by peer)
Sat Feb 9 16:14:57 2013 [FakeData09,ERROR] [midas.c:9958:rpc_client_call,ERROR]
send_tcp() failed
Sat Feb 9 16:14:57 2013 [FakeData09,ERROR] [frontend_rpc.c:191:rpc_call,ERROR] No RPC to
master
Sat Feb 9 16:14:57 2013 [master,ERROR] [midas.c:10844:recv_tcp_server,ERROR] Cannot
allocate 268435512 bytes for network buffer
Sat Feb 9 16:14:57 2013 [master,ERROR] [midas.c:12893:rpc_server_receive,ERROR]
recv_tcp_server() returned -1, abort
Sat Feb 9 16:14:57 2013 [master,TALK] Program 'FakeData09' on host 'fe01' aborted
After this it recycles just the first three errors that I mentioned above. |
|
862
|
12 Feb 2013 |
Stefan Ritt | Forum | send_tcp error | Ok, now the picture is clearer. I have however no idea what the real problem is. The number of concurrent programs in midas is 64 as defined in midas.h (MAX_CLIENTS) so that should not be the problem. In our experiment we run 10 front-ends (but
on 10 different machines) without problems. Other experiments used 27 front-ends.
The TCP error you see comes probably from the fact that the mserver side crashes or quits, then the socket gets broken. What you can try to debug this is to run mserver manually. Just remove mserver from inetd, and start it with "mserver -d" and
watch what happens. Do you see any additional error messages. If the mserver segfaults, you should turn on core dumps and have a look there. Note that the mserver starts a child process on each incoming connection, so running mserver in gdb
does not really help, since the child processes (which connect back to the front-ends) are not seen by gdb.
Have you tried to run the 9 front-ends on maybe two different PCs (5 and 4) to see if the problem is on the client side?
Best regards,
Stefan |
|
865
|
19 Feb 2013 |
Wes Gohn | Forum | send_tcp error |
Thank you for the help. As it turns out, the problem was due to the fact that we were compiling MIDAS on our 64 bit backend machine, but one of the frontend machines is 32 bit. The problem was resolved by compiling a 32 bit version of MIDAS in
addition to the 64 bit version. |
|
2270
|
19 Aug 2021 |
Konstantin Olchanski | Bug Report | select() FD_SETSIZE overrun | I am looking at the mlogger in the ALPHA anti-hydrogen experiment at CERN. It is
mysteriously misbehaving during run start and stop.
The problem turns out to be with the select() system call.
The corresponding FD_SET(), FD_ISSET() & co operate on a an array of fixed size
FD_SETSIZE, value 1024, in my case. But the socket number is 1409, so we overrun
the FD_SET() array. Ouch.
I see that all uses of select() in midas have no protection against this.
(we should probably move away from select() to newer poll() or whatever it is)
Why does mlogger open so many file descriptors? The usual, scaling problems in the
history. The old midas history does not reuse file descriptors, so opens the same
3 history files (.hst, .idx, etc) for each history event. The new FILE history
opens just one file per history event. But if the number of events is bigger than
1024, we run into same trouble.
(BTW, the system limit on file descriptors is 4096 on the affected machine, 1024
on some other machines, see "limit" or "ulimit -a").
K.O. |
|
2271
|
20 Aug 2021 |
Stefan Ritt | Bug Report | select() FD_SETSIZE overrun | > I am looking at the mlogger in the ALPHA anti-hydrogen experiment at CERN. It is
> mysteriously misbehaving during run start and stop.
>
> The problem turns out to be with the select() system call.
>
> The corresponding FD_SET(), FD_ISSET() & co operate on a an array of fixed size
> FD_SETSIZE, value 1024, in my case. But the socket number is 1409, so we overrun
> the FD_SET() array. Ouch.
>
> I see that all uses of select() in midas have no protection against this.
>
> (we should probably move away from select() to newer poll() or whatever it is)
>
> Why does mlogger open so many file descriptors? The usual, scaling problems in the
> history. The old midas history does not reuse file descriptors, so opens the same
> 3 history files (.hst, .idx, etc) for each history event. The new FILE history
> opens just one file per history event. But if the number of events is bigger than
> 1024, we run into same trouble.
>
> (BTW, the system limit on file descriptors is 4096 on the affected machine, 1024
> on some other machines, see "limit" or "ulimit -a").
>
> K.O.
I cannot imagine that you have more than 1024 different events in ALPHA. That wouldn't
fit on your status page.
I have some other suspicion: The logger opens a history file on access, then closes it
again after writing to it. In the old days we had a case where we had a return from the
write function BEFORE the file has been closed. This is kind of a memory leak, but with
file descriptors. After some time of course you run out of file descriptors and crash.
Now that bug has been fixed many years ago, but it sounds to me like there is another
"fd leak" somewhere. You should add some debugging in the history code to print the
file descriptors when you open a file and when you leave that routine. The leak could
however also be somewhere else, like writing to the message file, ODB dump, ...
The right thing of course would be to rewrite everything with std::ofstream which
closes automatically the file when the object gets out of scope.
Stefan |
|