int l2415___store(struct descriptor *niddsc, InStoreStruct *setup)
{
static int polarity_nid;
static int range_nid;
static int volt_out_nid;
static int curr_out_nid;
static DESCRIPTOR_NID(polarity_dsc,&polarity_nid);
static DESCRIPTOR_NID(range_dsc,&range_nid);
static struct descriptor_xd out_xd = {0, DTYPE_DSC, CLASS_XD, 0, 0};
int status=1;
static short voltage;
static struct descriptor voltage_dsc = {sizeof(short), DTYPE_W, CLASS_S, (char *)&voltage};
static DESCRIPTOR(volt_expr, "BUILD_WITH_UNITS($ * $ * ($ == 3500. ? 1. : 2.), 'Volts')");
static short current;
static struct descriptor current_dsc = {sizeof(short), DTYPE_W, CLASS_S, (char *)¤t};
static DESCRIPTOR(current_expr, "BUILD_WITH_UNITS($ * ( $ == 3500. ? .0025/4096. : .001/4096.) , 'Amps')");
polarity_nid = setup->head_nid + L2415_N_POLARITY;
range_nid = setup->head_nid + L2415_N_RANGE;
pio(26,0,0); /* convert output voltage to digital */
qrep(0,0,1,&voltage); /* read it when we get q back */
TdiCompile(&volt_expr, &voltage_dsc, &polarity_dsc, &range_dsc, &out_xd MDS_END_ARG);
volt_out_nid = setup->head_nid + L2415_N_VOLT_OUT;
return_on_error(TreePutRecord(volt_out_nid, (struct descriptor *)&out_xd, 0), status);
pio(26,1,0); /* convert output current to digital */
qrep(0,0,1,¤t); /* read it when we get q back */
TdiCompile(¤t_expr, ¤t_dsc, &range_dsc, &out_xd MDS_END_ARG);
curr_out_nid = setup->head_nid + L2415_N_CURR_OUT;
return_on_error(TreePutRecord(curr_out_nid, (struct descriptor *)&out_xd, 0), status);
/* turn it off */
/*
pio(16,0,0)
pio(16,1,0)
*/
return 1;
}
static char *MdsGetString(char *in)
{
char *out = NULL;
int status;
struct descriptor in_d = {0,DTYPE_T,CLASS_S,0};
EMPTYXD(xd);
in_d.length = strlen(in);
in_d.pointer = in;
status = TdiCompile(&in_d, &xd MDS_END_ARG);
if(status & 1)
status = TdiData(&xd, &xd MDS_END_ARG);
if(!(status & 1))
{
strncpy(error_message, MdsGetMsg(status), 512);
return NULL;
}
if(!xd.pointer)
{
strcpy(error_message, "Missing data");
return NULL;
}
if(xd.pointer->dtype != DTYPE_T)
{
MdsFree1Dx(&xd, NULL);
strcpy(error_message, "Not a string");
return NULL;
}
out = (char *)malloc(xd.pointer->length + 1);
memcpy(out, xd.pointer->pointer, xd.pointer->length);
out[xd.pointer->length] = 0;
MdsFree1Dx(&xd, NULL);
error_message[0] = 0;
return out;
}
int joerger_adcp___store(struct descriptor *nid_dsc, InStoreStruct *setup)
{
int status;
int chan;
static int c_nids[JOERGER_ADCP_K_CONG_NODES];
static DESCRIPTOR(output_expr, "$*$");
static short int buffer[16];
static DESCRIPTOR_A(buffer_dsc, sizeof(short int), DTYPE_W, &buffer, sizeof(buffer));
static float coef;
static DESCRIPTOR_FLOAT(coef_dsc, &coef);
static struct descriptor_xd output_xd = {0, DTYPE_DSC, CLASS_XD, 0, 0};
static float coefs[] = {20.48/4096, 10.24/4096, 10.24/4096, 5.12/4096};
struct _op_mode {
unsigned int mode:2;
unsigned int coef:2;
unsigned int cont:1;
unsigned int :11;
} operating_mode;
return_on_error(DevNids(nid_dsc,sizeof(c_nids),c_nids));
if (setup->no_trig) {
float wait = 10E-6*16;
pio(26, 0, 0);
return_on_error(DevWait(wait));
}
for (chan=0; chan<16; chan++)
pio(0,chan,&buffer[chan]);
pio(1,15, (short *)&operating_mode);
coef = coefs[operating_mode.coef];
return_on_error(TdiCompile(&output_expr, &buffer_dsc, &coef_dsc, &output_xd MDS_END_ARG));
status = TreePutRecord(c_nids[JOERGER_ADCP_N_INPUTS], (struct descriptor *)&output_xd,0);
return status;
}
JNIEXPORT void JNICALL Java_LocalDataProvider_SetEnvironmentSpecific(JNIEnv *env, jobject obj,
jstring in, jstring jdefNode)
{
int status, nid;
const char *in_char = (*env)->GetStringUTFChars(env, in, 0);
const char *defNode;
struct descriptor in_d = {0,DTYPE_T,CLASS_S,0};
EMPTYXD(xd);
error_message[0] = 0;
if(in_char && *in_char)
{
in_d.length = strlen(in_char);
in_d.pointer = (char *)in_char;
status = TdiCompile(&in_d, &xd MDS_END_ARG);
if(status & 1)
status = TdiData(&xd, &xd MDS_END_ARG);
if(!(status & 1))
strncpy(error_message, MdsGetMsg(status), 512);
MdsFree1Dx(&xd, NULL);
(*env)->ReleaseStringUTFChars(env, in, in_char);
}
if(jdefNode)
{
defNode = (*env)->GetStringUTFChars(env, jdefNode, 0);
status = TreeFindNode((char *)defNode, &nid);
if(status & 1)
TreeSetDefaultNid(nid);
(*env)->ReleaseStringUTFChars(env, jdefNode, defNode);
}
}
static float MdsGetFloat(char *in)
{
float ris = 0;
int status;
struct descriptor in_d = {0,DTYPE_T,CLASS_S,0};
EMPTYXD(xd);
in_d.length = strlen(in);
in_d.pointer = in;
status = TdiCompile(&in_d, &xd MDS_END_ARG);
if(status & 1)
status = TdiData(&xd, &xd MDS_END_ARG);
if(status & 1)
status = TdiFloat(&xd, &xd MDS_END_ARG);
if(!(status & 1))
{
strncpy(error_message, MdsGetMsg(status), 512);
return 0;
}
if(!xd.pointer)
{
strcpy(error_message, "Missing data");
return 0;
}
if(xd.pointer->class != CLASS_S)
{
strcpy(error_message, "Not a scalar");
return 0;
}
switch(xd.pointer->dtype) {
case DTYPE_BU:
case DTYPE_B : ris = (float)(*(char *)xd.pointer->pointer); break;
case DTYPE_WU:
case DTYPE_W : ris = (float)(*(short *)xd.pointer->pointer); break;
case DTYPE_LU:
case DTYPE_L : ris = (float)(*(int *)xd.pointer->pointer); break;
case DTYPE_F : ris = *(float *)xd.pointer->pointer; break;
case DTYPE_FS: ris = *(float *)xd.pointer->pointer; break;
case DTYPE_D :
case DTYPE_G : ris = *(float *)xd.pointer->pointer; break;
default: sprintf(error_message, "Not a supported type %d", xd.pointer->dtype);
return 0;
}
MdsFree1Dx(&xd, NULL);
error_message[0] = 0;
return ris;
}
int ec727___store(struct descriptor *niddsc_ptr, InStoreStruct *setup)
{
static DESCRIPTOR(sigdef,"BUILD_SIGNAL(BUILD_WITH_UNITS($,'counts'),*,$[ $ : $ ])");
static DESCRIPTOR_A_BOUNDS(raw,sizeof(int),DTYPE_L,0,1,0);
static DESCRIPTOR_LONG(start_d,&raw.bounds[0].l);
static DESCRIPTOR_LONG(end_d,&raw.bounds[0].u);
static EMPTYXD(signal);
static int xfer_in;
static DESCRIPTOR_NID(xfer_in_d,&xfer_in);
int data[1024][32];
int cdata[1024];
int *dptr = (int *)data;
int status;
int i;
int chan;
xfer_in = setup->head_nid + EC727_N_XFER_IN;
pio(17,0);
for (i=0;i<4;i++,dptr += 8192) stop(0,0,8192,dptr);
for (chan=0;((chan < 32) && (status & 1));chan++)
{
int c_nid = setup->head_nid + EC727_N_INPUT_01 + chan * (EC727_N_INPUT_02 - EC727_N_INPUT_01);
int s_nid = c_nid + EC727_N_INPUT_01_STARTIDX - EC727_N_INPUT_01;
int e_nid = c_nid + EC727_N_INPUT_01_ENDIDX - EC727_N_INPUT_01;
if (TreeIsOn(c_nid) & 1)
{
status = DevLong(&s_nid,(int *)&raw.bounds[0].l);
if (status&1) raw.bounds[0].l = min(1023,max(0,raw.bounds[0].l));
else raw.bounds[0].l = 0;
status = DevLong(&e_nid, (int *)&raw.bounds[0].u);
if (status&1) raw.bounds[0].u = min(1023,max(0,raw.bounds[0].u));
else raw.bounds[0].u = 1023;
raw.m[0] = raw.bounds[0].u - raw.bounds[0].l + 1;
if (raw.m[0] > 0)
{
for (i=0;i<1024;i++) cdata[i] = data[i][chan];
raw.pointer = (char *)(cdata + (raw.bounds[0].l));
raw.a0 = (char *)cdata;
raw.arsize = raw.m[0] * 4;
TdiCompile(&sigdef,&raw,&xfer_in_d,&start_d,&end_d,&signal MDS_END_ARG);
status = TreePutRecord(c_nid,(struct descriptor *)signal.pointer,0);
}
}
}
return status;
}
int joerger_adc___store(int *niddsc, InStoreStruct *setup)
{
int status;
int data_nid = setup->head_nid + JOERGER_ADC_N_DATA;
if (TreeIsOn(data_nid)&1)
{
static short raw[64];
static ARRAY_BOUNDS(short,1) raw_d = {4,DTYPE_W,CLASS_A,raw,0,0,{0,0,1,1,1},1,sizeof(raw),raw-1,32,1,32};
static int vstrap_nid;
static DESCRIPTOR_NID(vstrap_d,&vstrap_nid);
static EMPTYXD(xd);
static DESCRIPTOR(expr,"BUILD_WITH_UNITS($ * $/4095,'VOLTS'");
int bytcnt;
vstrap_nid = setup->head_nid + JOERGER_ADC_N_VSTRAP;
return_on_error(DevCamChk(CamQstopw(setup->name,0,2,64,&raw,16,0),&one,0),status);
bytcnt = CamBytcnt(0);
raw_d.arsize = bytcnt;
raw_d.m[0] = raw_d.bounds[0].u = bytcnt/2;
TdiCompile(expr,&raw_d,&vstrap_d,&xd MDS_END_ARG);
status = TreePutRecord(data_nid,(struct descriptor *)&xd,0);
}
return status;
}
static int Put(unsigned short int *buffer, int pts_per_chan, int chans, int clock_nid, int nid)
{
DESCRIPTOR_A_COEFF_2 (a_dsc, sizeof(short), DTYPE_W, (char *)0, 0, 0, 0);
DESCRIPTOR(expr, "BUILD_SIGNAL(BUILD_WITH_UNITS($VALUE*.25E-12,'Coulombs'), build_with_units($,'counts'), $, \
build_with_units(0 : $ : 1, 'Channel'))");
struct descriptor_s clock_nid_dsc = {sizeof(int), DTYPE_NID, CLASS_S, (char *)0};
int max_chan_num = chans-1;
struct descriptor_s num_dsc = {sizeof(int), DTYPE_L, CLASS_S, (char *)0};
static struct descriptor_xd output_xd = {0, DTYPE_DSC, CLASS_XD, 0, 0};
int status;
a_dsc.pointer = (char *)buffer;
a_dsc.arsize = pts_per_chan*chans*sizeof(short);
a_dsc.m[0] = pts_per_chan;
a_dsc.m[1] = chans;
clock_nid_dsc.pointer = (char *)&clock_nid;
num_dsc.pointer = (char *)&max_chan_num;
status = TdiCompile(&expr, &a_dsc, &clock_nid_dsc, &num_dsc, &output_xd MDS_END_ARG);
if (status&1) {
status = TreePutRecord(nid, (struct descriptor *)&output_xd,0);
MdsFree1Dx(&output_xd,0);
}
return status;
}
/****************************************************************
* TclDoMethod:
****************************************************************/
int TclDoMethod()
{
int i;
int argc;
int sts;
unsigned char do_it;
struct descriptor_xd xdarg[255];
static int nid;
static unsigned short boolVal;
static struct descriptor_s bool_dsc =
{sizeof(boolVal), DTYPE_W, CLASS_S, (char *)&boolVal};
static struct descriptor nid_dsc = {4,DTYPE_NID,CLASS_S,(char *)&nid};
static struct descriptor_xd empty_xd = {0,DTYPE_DSC,CLASS_XD,0,0};
static DYNAMIC_DESCRIPTOR(arg);
static DYNAMIC_DESCRIPTOR(if_clause);
static DYNAMIC_DESCRIPTOR(method);
static DYNAMIC_DESCRIPTOR(object);
static void *arglist[256] = {(void *)2,&nid_dsc,&method};
cli_get_value("OBJECT",&object);
sts = TreeFindNode(object.dscA_pointer,&nid);
if (sts & 1)
{
do_it = (TreeIsOn(nid) | cli_present("OVERRIDE")) & 1;
if (cli_present("IF") & 1)
{
cli_get_value("IF",&if_clause);
sts = TdiExecute(&if_clause,&bool_dsc MDS_END_ARG);
if (sts & 1)
do_it = do_it && boolVal;
else
do_it = 0;
}
if (do_it)
{
int dometh_stat;
DESCRIPTOR_LONG(dometh_stat_d,0);
cli_get_value("METHOD",&method);
argc = 0;
if (cli_present("ARGUMENT") & 1)
{
while (cli_get_value("ARGUMENT",&arg) & 1)
{
xdarg[argc] = empty_xd;
sts = TdiCompile(&arg,&xdarg[argc] MDS_END_ARG);
if (sts & 1)
{
arglist[argc + 3] = xdarg[argc].dscA_pointer;
argc++;
}
else
break;
}
}
if (sts & 1)
{
#ifdef vms
arglist[0] = (void *)(argc + 2);
#else
dometh_stat_d.dscA_pointer = (char *)&dometh_stat;
arglist[argc+3] = &dometh_stat_d;
arglist[argc+4] = MdsEND_ARG;
arglist[0] = (argc + 4)+(char *)0;
#endif
sts = (char *)LibCallg(arglist,TreeDoMethod)-(char *)0;
if (sts & 1) sts = dometh_stat;
}
str_free1_dx(&arg);
str_free1_dx(&method);
for (i = 0; i < argc; i++)
MdsFree1Dx(&xdarg[i],NULL);
}
}
str_free1_dx(&object);
#ifdef vms
if (!(sts & 1)) lib$signal(sts,0);
#else
if (!(sts & 1))
{
char msg[512];
sprintf(msg,"Error executing method - %s",MdsGetMsg(sts));
TclTextOut(msg);
}
#endif
return sts;
}
int mit_clock__get_setup(Dptr niddsc_ptr, Dptr method, DecoderSetup *setup, EventMask *event_mask, Dptr *output)
{
int status;
InGet_setupStruct s;
status = mit_clock___get_setup(niddsc_ptr,&s);
if (status & 1)
{
float duty_cycle;
int invert = 0;
static float frequency[2];
float max_period;
float period;
static float dt;
DESCRIPTOR_FLOAT(dt_dsc,&dt);
int pulses;
int clock_source;
static DESCRIPTOR(expr, "* : * : $");
static EMPTYXD(out);
DESCRIPTOR_A(frequency_a,sizeof(float),DTYPE_NATIVE_FLOAT,(char *)frequency,sizeof(frequency));
memset(event_mask,0,sizeof(EventMask));
status = TdiData(s.frequency,(struct descriptor *)&frequency_a MDS_END_ARG);
if (!(status & 1))
{
status = TIMING$_INVCLKFRQ;
goto error;
}
if (frequency[1] == frequency[0])
duty_cycle = .5;
else if (frequency[1] < 0.0)
{
invert = 1;
duty_cycle = -frequency[1];
}
else if (frequency[1] > 0.0)
duty_cycle = frequency[1];
if ( (frequency[0] <= 0.0) || (duty_cycle <= 0.0) || (duty_cycle >= 1.0) )
{
status = TIMING$_INVCLKFRQ;
goto error;
}
max_period = 1/frequency[0];
for (clock_source = EXT_1MHZ, period = 1E-6;
period * 65534 < max_period && clock_source <= EXT_100HZ; clock_source++, period *= 10);
if (clock_source > EXT_100HZ)
{
status = TIMING$_INVCLKFRQ;
goto error;
}
setup->output_control = TOGGLE;
setup->start_high = 0;
setup->count_up = 0;
setup->bcd_count = 0;
setup->repeat_count = 1;
setup->double_load = 1;
setup->special_gate = 0;
setup->clock_source = clock_source;
setup->falling_edge = 0;
setup->gating = GATE_NONE;
pulses = max_period/period + .4999;
setup->load = pulses * duty_cycle + .4999;
setup->hold = pulses - setup->load;
if (setup->load == 0)
{
setup->load++;
setup->hold--;
}
if (setup->hold == 0)
{
setup->load--;
setup->hold++;
}
dt = period*(setup->load + setup->hold);
if (invert)
{
int tmp = setup->load;
setup->load = setup->hold;
setup->hold = tmp;
setup->start_high = 1;
}
status = TdiCompile(&expr, &dt_dsc, &out MDS_END_ARG);
if (status&1) {
static int output_nid;
static DESCRIPTOR_NID(output_dsc,(char *)&output_nid);
output_nid = s.head_nid + MIT_CLOCK_N_OUTPUT;
status = TreePutRecord(output_nid, (struct descriptor *)&out,0);
if (status&1) *output = &output_dsc; else *output=0;
}
else
*output = 0;
GenDeviceFree(&s);
}
return status;
error:
GenDeviceFree(&s);
return status;
}
int b2408___store(struct descriptor *niddsc, InStoreStruct *setup)
{
int i;
int j;
int npts;
int status = 1;
static int trig_nid;
static DESCRIPTOR_NID(trig_dsc, &trig_nid);
static int ext_clock_nid;
static DESCRIPTOR_NID(clock_dsc, &ext_clock_nid);
static int buffer[2048];
static DESCRIPTOR_A(buffer_dsc, sizeof(int), DTYPE_L, buffer, 0);
static float clock_mult;
static DESCRIPTOR_FLOAT(clock_mult_dsc, &clock_mult);
static struct descriptor_xd xd = {0, DTYPE_DSC, CLASS_XD, 0, 0};
static DESCRIPTOR(expr, "BUILD_SIGNAL(BUILD_WITH_UNITS(SLOPE_OF($)*$*$VALUE+$,\"Seconds\"), $, *)");
static DESCRIPTOR(int_clock_expr, "BUILD_SIGNAL(BUILD_WITH_UNITS(1E-6*$*$VALUE+$,\"Seconds\"), $, *)");
static float multipliers[] = {1, 10, 100, 1000};
static int zero = 0;
int output_nid = setup->head_nid+B2408_N_TIMEBASE;
StatusReg status_reg;
ext_clock_nid = setup->head_nid+B2408_N_EXT_CLOCK;
trig_nid = setup->head_nid+B2408_N_TRIGGER;
if (XmdsIsOn(output_nid)) {
pio(24,0,0,16);
pio(1,0,(int *)&status_reg,24);
npts = status_reg.npts;
clock_mult = multipliers[status_reg.freq];
if (npts > 0) {
int ok,tries;
for (ok=0,tries=0;tries < 100 && !ok; tries++) {
pio(16,0,&zero,16);
stop(2,0,npts,buffer);
ok = 1;
for (j=1;j<npts;j++) {
if (buffer[j-1] > buffer[j]) {
ok = 0;
break;
}
}
}
if (tries > 1) {
char comment_c[80];
struct descriptor comment={0,DTYPE_T,CLASS_S,0};
int comment_nid = setup->head_nid+B2408_N_COMMENT;
sprintf(comment_c,"Increasing times %sobtained after %d attempts",ok ? "" : "not ",tries);
comment.length = strlen(comment_c);
comment.pointer = comment_c;
TreePutRecord(comment_nid, (struct descriptor *)&comment,0);
}
} else
return DEV$_NOT_TRIGGERED;
buffer_dsc.arsize = npts*sizeof(int);
/* if (status_reg.ext_clk) { */
if (1) {
return_on_error(TdiCompile(&expr, &clock_dsc, &clock_mult_dsc, &trig_dsc, &buffer_dsc, (struct descriptor *)&xd MDS_END_ARG),status);
}
else {
return_on_error(TdiCompile(&int_clock_expr, &clock_mult_dsc, &trig_dsc, &buffer_dsc, (struct descriptor *)&xd MDS_END_ARG),status);
}
return_on_error(TreePutRecord(output_nid, (struct descriptor *)&xd,0), status);
}
/* return (status_reg.overflow) ? B2408$_OVERFLOW : (status_reg.trig_lim) ? B2408$_TRIG_LIM : 1; */
return (status_reg.overflow) ? B2408$_OVERFLOW : 1;
}
static void *MdsGetArray(char *in, int *out_dim, int is_float, int is_byte, int is_double)
{
float *float_ris = NULL;
double *double_ris = NULL;
int *int_ris = NULL;
char *byte_ris = NULL;
int status, dim, i;
struct descriptor in_d = {0,DTYPE_T,CLASS_S,0};
EMPTYXD(xd);
struct descriptor_a *arr_ptr;
char *expanded_in;
error_message[0] = 0;
*out_dim = 0;
if(is_float)
{
expanded_in = malloc(strlen(in) + 16);
sprintf(expanded_in, "fs_float((%s))", in);
in_d.length = strlen(expanded_in);
in_d.pointer = expanded_in;
}
else if(is_double)
{
expanded_in = malloc(strlen(in) + 16);
sprintf(expanded_in, "ft_float((%s))", in);
in_d.length = strlen(expanded_in);
in_d.pointer = expanded_in;
}
else
{
expanded_in = malloc(strlen(in) + 16);
sprintf(expanded_in, "long((%s))", in);
in_d.length = strlen(expanded_in);
in_d.pointer = expanded_in;
/* in_d.length = strlen(in);
in_d.pointer = in;*/
}
status = TdiCompile(&in_d, &xd MDS_END_ARG);
if(is_float) free(expanded_in);
if(status & 1)
status = TdiData(&xd, &xd MDS_END_ARG);
if(!(status & 1))
{
strncpy(error_message, MdsGetMsg(status), 512);
return 0;
}
if(!xd.pointer)
{
strcpy(error_message, "Missing data");
return 0;
}
if(xd.pointer->class != CLASS_A)
{
if(!is_float && !is_double) /*Legal only if used to retrieve the shot number*/
{
int_ris = malloc(sizeof(int));
switch(xd.pointer->dtype)
{
case DTYPE_BU:
case DTYPE_B : int_ris[0] = *((char *)xd.pointer->pointer); break;
case DTYPE_WU:
case DTYPE_W : int_ris[0] = *((short *)xd.pointer->pointer); break;
case DTYPE_LU:
case DTYPE_L : int_ris[0] = *((int *)xd.pointer->pointer); break;
case DTYPE_F :
case DTYPE_FS : int_ris[0] = *((int *)xd.pointer->pointer); break;
}
*out_dim = 1;
return int_ris;
}
strcpy(error_message, "Not an array");
return 0;
}
arr_ptr = (struct descriptor_a *)xd.pointer;
/* if(arr_ptr->dtype == DTYPE_F ||
arr_ptr->dtype == DTYPE_D ||
arr_ptr->dtype == DTYPE_G ||
arr_ptr->dtype == DTYPE_H)
{
status = TdiFloat(&xd, &xd MDS_END_ARG);
arr_ptr = (struct descriptor_a *)xd.pointer;
}
*/
*out_dim = dim = arr_ptr->arsize/arr_ptr->length;
if(is_float)
float_ris = (float *)malloc(sizeof(float) * dim);
else if(is_double)
double_ris = (double *)malloc(sizeof(double) * dim);
else if(is_byte)
byte_ris = malloc(dim);
else
int_ris = (int *)malloc(sizeof(int) * dim);
switch(arr_ptr->dtype) {
case DTYPE_BU:
case DTYPE_B :
for(i = 0; i < dim; i++)
if(is_float)
float_ris[i] = ((char *)arr_ptr->pointer)[i];
else if(is_double)
double_ris[i] = ((char *)arr_ptr->pointer)[i];
else if(is_byte)
byte_ris[i] = ((char *)arr_ptr->pointer)[i];
else
int_ris[i] = ((char *)arr_ptr->pointer)[i];
break;
case DTYPE_WU:
case DTYPE_W :
for(i = 0; i < dim; i++)
if(is_float)
float_ris[i] = ((short *)arr_ptr->pointer)[i];
else if(is_double)
double_ris[i] = ((char *)arr_ptr->pointer)[i];
else if(is_byte)
byte_ris[i] = (char)(((short *)arr_ptr->pointer)[i]);
else
int_ris[i] = ((short *)arr_ptr->pointer)[i];
break;
case DTYPE_LU:
case DTYPE_L :
for(i = 0; i < dim; i++)
if(is_float)
float_ris[i] = (float)(((int *)arr_ptr->pointer)[i]);
if(is_double)
double_ris[i] = (double)(((int *)arr_ptr->pointer)[i]);
else if(is_byte)
byte_ris[i] = ((int *)arr_ptr->pointer)[i];
else
int_ris[i] = ((int *)arr_ptr->pointer)[i];
break;
case DTYPE_F :
case DTYPE_FS :
for(i = 0; i < dim; i++)
if(is_float)
float_ris[i] = ((float *)arr_ptr->pointer)[i];
else if(is_double)
double_ris[i] = (double)((float *)arr_ptr->pointer)[i];
else if(is_byte)
byte_ris[i] = (char)(((float *)arr_ptr->pointer)[i]);
else
int_ris[i] = (int)(((float *)arr_ptr->pointer)[i]);
break;
case DTYPE_FT :
for(i = 0; i < dim; i++)
if(is_float)
float_ris[i] = (float)((double *)arr_ptr->pointer)[i];
else if(is_double)
{
double_ris[i] = ((double *)arr_ptr->pointer)[i];
}
else if(is_byte)
byte_ris[i] = (char)(((double *)arr_ptr->pointer)[i]);
else
int_ris[i] = (int)(((double *)arr_ptr->pointer)[i]);
break;
case DTYPE_D :
case DTYPE_G :
default: strcpy(error_message, "Not a supported type");
return NULL;
}
MdsFree1Dx(&xd, NULL);
error_message[0] = 0;
if(is_float)
return float_ris;
else if(is_double)
return double_ris;
else if(is_byte)
return byte_ris;
return int_ris;
}
int hv1440___store(struct descriptor *niddsc, InStoreStruct *setup)
{
int count;
int need_pod=0;
int status = 1;
int pod;
int ind;
int i;
int j;
float volt;
int vmax;
int vfmax=0;
int nfmax=0;
int pods[HV1440_K_MAX_PODS];
int f2;
static int settings[HV1440_K_MAX_CHANNELS];
static float f_settings[HV1440_K_MAX_CHANNELS];
static DESCRIPTOR(out_dsc, "BUILD_WITH_UNITS($, 'Volts')");
static DESCRIPTOR_A(settings_dsc, sizeof(float), DTYPE_F, f_settings, sizeof(f_settings));
static struct descriptor_xd out_xd = {0, DTYPE_DSC, CLASS_XD, 0, 0};
vmax = ((setup->range == 1.0) ||
(setup->range == .625)) ? 2500 : (setup->range == .5) ? 2046 : (setup->range == .375) ? 1534 : 0;
if (! vmax) return HV1440$_BAD_RANGE;
for (pod=0,ind=0; pod<HV1440_K_MAX_PODS; pod++, ind+= HV1440_K_CHANS_PER_POD)
pods[pod] = GetPodSettings(setup->head_nid + HV1440_N_POD_01 + pod, &settings[ind]);
for (i=0; i<HV1440_K_MAX_CHANNELS; i++) {
int abset = abs(settings[i]);
if (abset > vmax) return HV1440$_OUTRNG;
if (abset > vfmax) {
vfmax = abset;
nfmax = i;
}
}
pio(9,0,0);
pio(10,0,0);
pio(26,1,0);
f2 = setup->frame*2;
send_hv(0, nfmax, f2, 0);
for (i=0; i<HV1440_K_MAX_PODS; i++) {
if (pods[i]) {
need_pod = i+1;
for(j=0; j<HV1440_K_CHANS_PER_POD; j++) {
struct v_read {
unsigned tag : 3;
unsigned voltage : 12;
unsigned sign_bit : 1;
} voltage;
int i0 = i*HV1440_K_CHANS_PER_POD+j;
send_hv(0, i0, 8, 3);
for (voltage.tag=0, count = 0; ((count < 25) && (voltage.tag != 2)); count++) {
static float time = .1;
LibWait(&time);
pio(2, 0, (short *)&voltage);
}
if (count > 1) printf("Readback took %d tries\n", count);
if (count == 25) return HV1440$_STUCK;
f_settings[i*HV1440_K_CHANS_PER_POD+j] = voltage.voltage*setup->range* (voltage.sign_bit ? 1. : -1.);
}
}
else
for(j=0; j < HV1440_K_CHANS_PER_POD; j++)
f_settings[i*HV1440_K_CHANS_PER_POD+j] = 0;
}
settings_dsc.arsize = sizeof(float)*need_pod*HV1440_K_CHANS_PER_POD;
if (need_pod) {
int readout_nid = setup->head_nid + HV1440_N_READOUT;
return_on_error(TdiCompile(&out_dsc, &settings_dsc, &out_xd MDS_END_ARG), status);
return_on_error(TreePutRecord(readout_nid, (struct descriptor *)&out_xd, 0), status);
MdsFree1Dx(&out_xd,0);
}
return 1;
}
int hm650___init(struct descriptor *niddsc, InInitStruct *setup)
{
int status = 1;
int dly_status = 1;
int put_status = 1;
unsigned short int_threshold;
int i;
float delays[8];
int zero=0;
pio(21,0,&zero,16);
int_threshold = (setup->threshold+2.5)/5. * 4095;
int_threshold = (min(max(int_threshold, 0), 4095));
pio(17,0,&int_threshold,16);
delays[0] = setup->delay_0;
delays[1] = setup->delay_1;
delays[2] = setup->delay_2;
delays[3] = setup->delay_3;
delays[4] = setup->delay_4;
delays[5] = setup->delay_5;
delays[6] = setup->delay_6;
delays[7] = setup->delay_7;
for (i=0; i<8; i++) {
unsigned short ndelay;
static float delay;
static DESCRIPTOR(expr, "BUILD_WITH_UNITS($ + $/1E-9, S)");
static DESCRIPTOR_FLOAT(delay_dsc,&delay);
static DESCRIPTOR_NID(trig_dsc,0);
delay = delays[i];
if (delay < 20.) {
delay = 20;
dly_status = HM650$_DLYCHNG;
}
if (delay <= 102.375)
ndelay = (int)(delay/102.4*4096);
else if (delay <= 1023.74)
ndelay = ((int)(delay/1024.*4096)) | (1<<12);
else if (delay <= 10237.5)
ndelay = ((int)(delay/10240.*4096)) | (2<<12);
else if (delay <= 102375.)
ndelay = ((int)(delay/102400.*4096)) | (3<<12);
else {
dly_status = HM650$_DLYCHNG;
ndelay = 0xFFFF;
}
pio(16,i,&ndelay,16);
if (status&1)
{
static struct descriptor_xd out_xd = {0, DTYPE_DSC, CLASS_XD, 0, 0};
int trig_in = setup->head_nid + HM650_N_TRIG_IN_0 + i;
int trig_out = setup->head_nid + HM650_N_TRIG_OUT_0 + i;
delay = (ndelay | 0xFFF)/4096.*102.4;
switch (ndelay >> 12) {
case 1: delay *= 10; break;
case 2: delay *= 100.; break;
case 3: delay *= 1000.; break;
}
trig_dsc.pointer = (char *)&trig_in;
put_status = TdiCompile(&expr, &trig_dsc, &delay_dsc MDS_END_ARG);
if (put_status&2)
put_status = TreePutRecord(trig_out, (struct descriptor *)&out_xd,0);
}
}
pio(21, 0, &zero, 16);
if ((status&1) == 0) return status;
else if ((dly_status&1) == 0) return dly_status;
else if ((put_status&1) == 0) return put_status;
else return 1;
}
