void sr844_UpdateControls(int panel, gpibioPtr dev)
{
sr844_CheckClear(dev);
SetCtrlIndex(panel, SR844_CTRL_TC, sr844_GetIntVal(dev, "OFLT?"));
sr844_CheckClear(dev);
SetCtrlIndex(panel, SR844_CTRL_SENS, sr844_GetIntVal(dev, "SENS?"));
sr844_CheckClear(dev);
SetCtrlVal(panel, SR844_CTRL_1MO50O, sr844_GetIntVal(dev, "INPZ?"));
sr844_CheckClear(dev);
SetCtrlVal(panel, SR844_CTRL_FILTSLOPE, sr844_GetIntVal(dev, "OFSL?"));
}
void CVICALLBACK clbMenuDeleteItem (int menuBar, int menuItem, void *callbackData, int panel)
{
int iIndex = 0,
iCurrentIndex = 0;
GetCtrlIndex ( panel , PANEL_COMMAND_NAME_LIST , &iCurrentIndex );
bSaveChanges = 1;
if ( iCurrentIndex < giNumberOfItems )
{
giNumberOfItems--;
for ( iIndex = giCurrentItemIndex; iIndex < giNumberOfItems; iIndex++ )
gvtListOfCommands[iIndex] = gvtListOfCommands[iIndex+1];
UpdateList( panel );
if ( iCurrentIndex >= giNumberOfItems )
iCurrentIndex = giNumberOfItems - 1;
if ( iCurrentIndex < 0 )
iCurrentIndex = 0;
giCurrentItemIndex = iCurrentIndex;
SetCtrlIndex ( panel , PANEL_COMMAND_NAME_LIST , iCurrentIndex );
UpdateCurrentItem( panel );
}
return;
}
int das1602_ControlCallback (int panel, int control, int event, void *callbackData, int eventData1, int eventData2)
{
portPtr port = callbackData;
switch (control)
{
case DAS_CTRL_RANGE:
if(event == EVENT_COMMIT && port)
GetCtrlVal(panel, control, &port->port.analogueIOport.range);
break;
case DAS_CTRL_INPUT:
if(event == EVENT_COMMIT && port)
{
int i;
MCCdevPtr dev = port->port.analogueIOport.IO.acqchan->dev;
das1602Ptr das = dev->device;
GetCtrlVal(panel, control, &i);
port->control = 0;
if(i != -1)
{
das->Achannels[i]->control = control;
SetCtrlAttribute (panel, control, ATTR_CALLBACK_DATA, das->Achannels[i]);
SetCtrlAttribute (panel, DAS_CTRL_RANGE, ATTR_CALLBACK_DATA, das->Achannels[i]);
SetCtrlAttribute (panel, DAS_CTRL_ACQ, ATTR_CALLBACK_DATA, das->Achannels[i]);
SetCtrlIndex (panel, DAS_CTRL_RANGE, das1602_IndexFromRange(das->Achannels[i]->port.analogueIOport.range));
SetCtrlVal (panel, DAS_CTRL_ACQ, das->Achannels[i]->port.analogueIOport.IO.acqchan->acquire);
}
SetCtrlAttribute (panel, DAS_CTRL_RANGE, ATTR_DIMMED, (i == -1));
SetCtrlAttribute (panel, DAS_CTRL_ACQ, ATTR_DIMMED, (i == -1));
if(i == -1)SetCtrlVal (panel, DAS_CTRL_ACQ, 0);
}
break;
case DAS_CTRL_ACQ:
if(event == EVENT_COMMIT && port && utilG.acq.status != ACQ_BUSY)
{
int i;
MCCdevPtr dev = port->port.analogueIOport.IO.acqchan->dev;
das1602Ptr das = dev->device;
GetCtrlIndex (panel, DAS_CTRL_INPUT, &i);
if(i)
{
GetCtrlVal (panel, control, &port->port.analogueIOport.IO.acqchan->acquire);
if (port->port.analogueIOport.IO.acqchan->acquire)
acqchanlist_AddChannel(port->port.analogueIOport.IO.acqchan);
else
acqchanlist_RemoveChannel(port->port.analogueIOport.IO.acqchan);
SetMenuBarAttribute (das->menu, port->menuitem_id, ATTR_CHECKED, port->port.analogueIOport.IO.acqchan->acquire);
}
else if(event == EVENT_COMMIT && utilG.acq.status == ACQ_BUSY)
SetCtrlVal (panel, control, port->port.analogueIOport.IO.acqchan->acquire);
}
break;
}
if(event == EVENT_COMMIT && port)
das1602_UpdateMeasurePanel (port);
return 0;
}
void InitManipulateCallback(int menubar, int menuItem, void *callbackData, int panel)
{
int i, height1, height2;
channelPtr chan;
channel_InitViewPanel();
InstallCtrlCallback (chanview.p1, CHANVIEW_CHANNELS,
ManipulateSelectionCallback, 0);
ClearListCtrl (chanview.p1, CHANVIEW_CHANNELS);
for (i = 0; i < channelG.channels.nItems; i++)
{
chan = channellist_GetItem (i);
if (!chan->curves.nItems)
InsertListItem (chanview.p1, CHANVIEW_CHANNELS, -1, chan->label, i);
}
SetCtrlIndex (chanview.p1, CHANVIEW_CHANNELS, 0);
GetCtrlVal (chanview.p1, CHANVIEW_CHANNELS, &i);
chan = channellist_GetItem (i);
InstallCtrlCallback (chanview.p1, CHANVIEW_GRAPH,
ManipulateGraphCallback, chan);
channel_UpdateViewPanel(chan);
SetCtrlAttribute (chanview.p1, CHANVIEW_GRAPH, ATTR_CTRL_MODE,
VAL_HOT);
SetCtrlAttribute (chanview.p1, CHANVIEW_GRAPH, ATTR_NUM_CURSORS, 1);
SetCursorAttribute (chanview.p1, CHANVIEW_GRAPH, 1, ATTR_CURSOR_MODE,
VAL_SNAP_TO_POINT);
SetCursorAttribute (chanview.p1, CHANVIEW_GRAPH, 1,
ATTR_CROSS_HAIR_STYLE, VAL_SHORT_CROSS);
SetCursorAttribute (chanview.p1, CHANVIEW_GRAPH, 1, ATTR_CURSOR_COLOR,
VAL_YELLOW);
GetPanelAttribute (chanview.p1, ATTR_HEIGHT, &height1);
chanview.p2 = LoadPanel (chanview.p1, "chanfncu.uir", MANIP);
GetPanelAttribute (chanview.p2, ATTR_HEIGHT, &height2);
SetPanelAttribute (chanview.p1, ATTR_HEIGHT, height1+height2+6);
SetPanelPos (chanview.p2, height1, 6);
InstallCtrlCallback (chanview.p2, MANIP_READING,
ManipulateReadingCallback, chan);
DisplayPanel (chanview.p2);
InstallPopup (chanview.p1);
MessagePopup ("Manipulate Channel Message", "Only channels not connected to a curve may be edited");
}
int UpdateCurrentItem( int panelHandle )
{
int iIndex = giCurrentItemIndex;
char szStringValue[LOW_STRING] = {0};
int iPortIndex = 0,
iCurrentTabIndex = 0;
int tabPanelHandle = 0;
GetActiveTabPage (panelHandle , PANEL_TAB , &iCurrentTabIndex );
GetPanelHandleFromTabPage ( panelHandle , PANEL_TAB , iCurrentTabIndex, &tabPanelHandle );
SetCtrlVal( panelHandle , PANEL_COMMAND_NAME_STRING , gvtListOfCommands[iIndex].szCommandName );
if (( gvtListOfCommands[iIndex].iConfigType == 1 ) || ( gvtListOfCommands[iIndex].iConfigType == 2 ))
SetTabPageAttribute ( panelHandle , PANEL_TAB , 2 , ATTR_VISIBLE, 1 );
else
SetTabPageAttribute ( panelHandle , PANEL_TAB , 2 , ATTR_VISIBLE, 0 );
if ( gvtListOfCommands[iIndex].iConfigType == 4 )
SetTabPageAttribute ( panelHandle , PANEL_TAB , 1 , ATTR_VISIBLE, 1 );
else
SetTabPageAttribute ( panelHandle , PANEL_TAB , 1 , ATTR_VISIBLE, 0 );
switch(iCurrentTabIndex)
{
case 0:
if ( gvtListOfCommands[iIndex].pBaudRateArray[0] )
sprintf( szStringValue , "%d" , gvtListOfCommands[iIndex].pBaudRateArray[0] );
else
strcpy( szStringValue , "-" );
SetCtrlVal( tabPanelHandle , DEFAULT_BOUD_RATE , szStringValue );
sprintf( szStringValue , "0x%02llX" , gvtListOfCommands[iIndex].BitDirectionMask );
SetCtrlVal( tabPanelHandle , DEFAULT_BIT_DIR_MASK , szStringValue );
sprintf( szStringValue , "%lf" , gvtListOfCommands[iIndex].lfSetTimeout );
SetCtrlVal( tabPanelHandle , DEFAULT_SET_TIMEOUT , szStringValue );
sprintf( szStringValue , "%lf" , gvtListOfCommands[iIndex].lfSetDelay );
SetCtrlVal( tabPanelHandle , DEFAULT_SET_DELAY , szStringValue );
sprintf( szStringValue , "%lf" , gvtListOfCommands[iIndex].dPowerUpLevel );
SetCtrlVal( tabPanelHandle , DEFAULT_POWER_UP_LEVEL , szStringValue );
if ( gvtListOfCommands[iIndex].lfMaxValue == 0.0 )
gvtListOfCommands[iIndex].lfMaxValue = 5.0;
sprintf( szStringValue , "%lf" , gvtListOfCommands[iIndex].lfMaxValue );
SetCtrlVal( tabPanelHandle , DEFAULT_MAX_VALUE , szStringValue );
sprintf( szStringValue , "%lf" , gvtListOfCommands[iIndex].lfMinValue );
SetCtrlVal( tabPanelHandle , DEFAULT_MIN_VALUE , szStringValue );
sprintf( szStringValue , "%d" , gvtListOfCommands[iIndex].valueCount );
SetCtrlVal( tabPanelHandle , DEFAULT_VALUE_COUNT , szStringValue );
sprintf( szStringValue , "0x%02llX" , gvtListOfCommands[iIndex].DefValue );
SetCtrlVal( tabPanelHandle , DEFAULT_DEFAULT_VALUE , szStringValue );
sprintf( szStringValue , "0x%02llX" , gvtListOfCommands[iIndex].UseBitsMap );
SetCtrlVal( tabPanelHandle , DEFAULT_USE_BITS_MAP , szStringValue );
if ( gvtListOfCommands[iIndex].iPortsQuantity == 0)
gvtListOfCommands[iIndex].iPortsQuantity = 1;
memset( szStringValue , 0 , LOW_STRING );
for ( iPortIndex = 0; iPortIndex < gvtListOfCommands[iIndex].iPortsQuantity; iPortIndex++ )
{
if ( iPortIndex > 0 )
strcat( szStringValue , "," );
sprintf( szStringValue + strlen(szStringValue) , "%d" , gvtListOfCommands[iIndex].pPortNumbersArray[iPortIndex] );
}
SetCtrlVal( tabPanelHandle , DEFAULT_PORTS , szStringValue );
SetCtrlVal( tabPanelHandle , DEFAULT_PULLING_TYPE , gvtListOfCommands[iIndex].bPullingState );
SetCtrlVal( tabPanelHandle , DEFAULT_DEVICE_NAME , gvtListOfCommands[iIndex].szDeviceName );
SetCtrlVal( tabPanelHandle , DEFAULT_VALUE_TYPE , gvtListOfCommands[iIndex].valueType );
SetCtrlVal( tabPanelHandle , DEFAULT_PILLING_STATE , gvtListOfCommands[iIndex].bPowerUpState );
if ( gvtListOfCommands[iIndex].iConfigType )
SetCtrlVal( tabPanelHandle , DEFAULT_CONFIG_TYPE , gvtListOfCommands[iIndex].iConfigType );
else
SetCtrlIndex( tabPanelHandle , DEFAULT_CONFIG_TYPE , 0 );
if ( gvtListOfCommands[iIndex].iMeasureType )
SetCtrlVal( tabPanelHandle , DEFAULT_MEASURE_TYPE , gvtListOfCommands[iIndex].iMeasureType );
else
SetCtrlIndex( tabPanelHandle , DEFAULT_MEASURE_TYPE , 0 );
break;
case 1:
break;
case 2:
sprintf( szStringValue , "%d" , gvtListOfCommands[iIndex].iAlalogMeasureNumberOfPoints );
SetCtrlVal( tabPanelHandle , MEAS_CONF_NUMBER_OF_POINTS , szStringValue );
sprintf( szStringValue , "%d" , gvtListOfCommands[iIndex].iAlalogMeasureSimpleRate );
SetCtrlVal( tabPanelHandle , MEAS_CONF_SIMPLE_RATE , szStringValue );
SetCtrlVal( tabPanelHandle , MEAS_CONF_MEASURE_FUNCTION , gvtListOfCommands[iIndex].iAlalogMeasureFunction );
break;
default:
break;
}
return 0;
}
void acquire_scans (void)
{
int color;
int Nleft=0;
char file [ FILENAME_MAX ];
SetCtrlAttribute (Main_pnl_handle, ERG_panel_acquire, ATTR_DIMMED, 1);
SetCtrlAttribute (Main_pnl_handle, ERG_panel_abortscan, ATTR_DIMMED, 1);
if (experiment==1){
GetCtrlVal (Sequence_pnl_handle, Seq_panel_seq_number, &seq_num);
Nscans= seq_num*m;
}
else {
GetCtrlVal (Main_pnl_handle, ERG_panel_nscans, &Nscans);
}
DirSelectPopup ("d:\\data\\test", "Select Directory", 1, 1, pathname);
i=0;
SetCtrlAttribute (Main_pnl_handle, ERG_panel_pause, ATTR_DIMMED, 0);
SetCtrlAttribute (Main_pnl_handle, ERG_panel_abortscan, ATTR_DIMMED, 0);
// start trigger
SRS_flag=2;
SRS_onoff();
DeleteGraphPlot (Main_pnl_handle, ERG_panel_mask_display, -1, VAL_IMMEDIATE_DRAW);
if (experiment==1){ // mode sequence
for (i=0;i<seq_num;i++) {
for (h=0;h<m;h++){
SetCtrlIndex (Sequence_pnl_handle, Seq_panel_mask_list, h);
for (k=0;k<Npixel;k++){
drive_level[k]=mask[h].voltages[k];
}
display_masks();
ProcessSystemEvents();
GetLabelFromIndex (Sequence_pnl_handle, Seq_panel_mask_list, h, &mask_filename);
strcpy(filename, pathname);
//prepare file to write
sprintf(file, "\\sequence%d_%s.txt", i, mask_filename);
strcat(filename, file);
data_file = OpenFile (filename, VAL_WRITE_ONLY, VAL_TRUNCATE, VAL_ASCII);
//enable oscillo then wait for trigger and get ERG trace
color=floor(256/Nscans)*(i*m+h);
waveform(color, data_file);
get_intensity();
//write header file
headerfile();
//write ERG trace
ArrayToFile (filename, data2fit, VAL_DOUBLE, 10000, 1, VAL_GROUPS_TOGETHER, VAL_GROUPS_AS_ROWS, VAL_SEP_BY_TAB, 100, VAL_ASCII, VAL_APPEND);
nmeasure[0]=i*m+h+1;
displaychannel();
Nleft=Nscans-(i*m+h);
SetCtrlVal (Main_pnl_handle, ERG_panel_nremain, Nleft);
ProcessSystemEvents();
if (pause_flag)
{
while (pause_flag)
ProcessSystemEvents();
}
}
}
}
else{ // mode normal
//prepare file name for acquiring data
while ( i < Nscans )
{
strcpy(filename, pathname);
sprintf(file, "\\scope_data%d.txt", i);
strcat(filename, file);
data_file = OpenFile (filename, VAL_WRITE_ONLY, VAL_TRUNCATE, VAL_ASCII);
color=floor(256/Nscans)*i;
waveform(color, data_file);
get_intensity();
headerfile();
ArrayToFile (filename, data2fit, VAL_DOUBLE, 10000, 1, VAL_GROUPS_TOGETHER, VAL_GROUPS_AS_ROWS, VAL_SEP_BY_TAB, 100, VAL_ASCII, VAL_APPEND);
i++;
Nleft=Nscans-i+1;
SetCtrlVal (Main_pnl_handle, ERG_panel_nremain, Nleft);
ProcessSystemEvents();
if (pause_flag)
{
while (pause_flag)
ProcessSystemEvents();
}
CloseFile (data_file);
}
}
SetCtrlVal (Main_pnl_handle, ERG_panel_nremain, 0);
SetCtrlAttribute (Main_pnl_handle, ERG_panel_pause, ATTR_DIMMED, 1);
SetCtrlAttribute (Main_pnl_handle, ERG_panel_abortscan, ATTR_DIMMED, 1);
SetCtrlAttribute (Main_pnl_handle, ERG_panel_acquire, ATTR_DIMMED, 0);
// stop trigger
SRS_flag=0;
SRS_onoff();
ibsic(device);
return;
}
int usb1208ls_ControlCallback (int panel, int control, int event, void *callbackData, int eventData1, int eventData2)
{
portPtr port = callbackData;
switch (control)
{
case USB1208LS_RANGE:
if(event == EVENT_COMMIT && port)
GetCtrlVal(panel, control, &port->port.analogueIOport.range);
break;
case USB1208LS_INPUT:
if(event == EVENT_COMMIT && port)
{
int i;
MCCdevPtr dev = port->port.analogueIOport.IO.acqchan->dev;
usb1208lsPtr pmd = dev->device;
GetCtrlVal(panel, control, &i);
port->control = 0;
if(i != -1)
{
pmd->aiPorts[i]->control = control;
SetCtrlAttribute (panel, control, ATTR_CALLBACK_DATA, pmd->aiPorts[i]);
SetCtrlAttribute (panel, USB1208LS_RANGE, ATTR_CALLBACK_DATA, pmd->aiPorts[i]);
SetCtrlAttribute (panel, USB1208LS_ACQ, ATTR_CALLBACK_DATA, pmd->aiPorts[i]);
SetCtrlAttribute (panel, USB1208LS_AVERAGE, ATTR_CALLBACK_DATA, pmd->aiPorts[i]);
SetCtrlVal (panel, USB1208LS_AVERAGE, pmd->aiPorts[i]->averaging);
SetCtrlIndex (panel, USB1208LS_RANGE, usb1208ls_IndexFromRange(pmd->aiPorts[i]->port.analogueIOport.range));
SetCtrlVal (panel, USB1208LS_ACQ, pmd->aiPorts[i]->port.analogueIOport.IO.acqchan->acquire);
}
SetCtrlAttribute (panel, USB1208LS_RANGE, ATTR_DIMMED, (i == -1));
SetCtrlAttribute (panel, USB1208LS_ACQ, ATTR_DIMMED, (i == -1));
if(i == -1)SetCtrlVal (panel, USB1208LS_ACQ, 0);
}
break;
case USB1208LS_ACQ:
if(event == EVENT_COMMIT && port && utilG.acq.status != ACQ_BUSY)
{
int i;
MCCdevPtr dev = port->port.analogueIOport.IO.acqchan->dev;
usb1208lsPtr pmd = dev->device;
GetCtrlIndex (panel, USB1208LS_INPUT, &i);
if(i)
{
GetCtrlVal (panel, control, &port->port.analogueIOport.IO.acqchan->acquire);
if (port->port.analogueIOport.IO.acqchan->acquire)
acqchanlist_AddChannel(port->port.analogueIOport.IO.acqchan);
else
acqchanlist_RemoveChannel(port->port.analogueIOport.IO.acqchan);
SetMenuBarAttribute (pmd->menu, port->menuitem_id, ATTR_CHECKED, port->port.analogueIOport.IO.acqchan->acquire);
}
}
else if(event == EVENT_COMMIT && utilG.acq.status == ACQ_BUSY)
SetCtrlVal (panel, control, port->port.analogueIOport.IO.acqchan->acquire);
break;
/*case USB1208LS_DIGITAL_OUT_0:
case USB1208LS_DIGITAL_OUT_1:
case USB1208LS_DIGITAL_OUT_2:
case USB1208LS_DIGITAL_OUT_3:
case USB1208LS_DIGITAL_OUT_4:
case USB1208LS_DIGITAL_OUT_5:
if(event == EVENT_COMMIT && port)
{
MCCdevPtr dev = port->port.digitalIOport.IO.source->acqchan->dev;
usb1208lsPtr pmd = dev->device;
GetCtrlVal (panel, USB1208LS_DIGITAL_OUT_0, &pmd->bits[0]);
GetCtrlVal (panel, USB1208LS_DIGITAL_OUT_1, &pmd->bits[1]);
GetCtrlVal (panel, USB1208LS_DIGITAL_OUT_2, &pmd->bits[2]);
GetCtrlVal (panel, USB1208LS_DIGITAL_OUT_3, &pmd->bits[3]);
GetCtrlVal (panel, USB1208LS_DIGITAL_OUT_4, &pmd->bits[4]);
GetCtrlVal (panel, USB1208LS_DIGITAL_OUT_5, &pmd->bits[5]);
pmd->bits[1] *= 2;
pmd->bits[2] *= 4;
pmd->bits[3] *= 8;
pmd->bits[4] *= 16;
pmd->bits[5] *= 32;
port->port.digitalIOport.IO.source->biaslevel = pmd->bits[0] + pmd->bits[1] + pmd->bits[2] + pmd->bits[3] + pmd->bits[4] + pmd->bits[5];
port->port.digitalIOport.IO.source->SetLevel(port->port.digitalIOport.IO.source);
}
break;*/
case USB1208LS_AVERAGE:
if(event == EVENT_COMMIT && port)
GetCtrlVal (panel, control, &port->averaging);
break;
}
if (event == EVENT_COMMIT && port)
usb1208ls_UpdateMeasurePanel(port);
return 0;
}
static void k2400_UpdateControls (int panel, gpibioPtr dev)
{
char s_text[20], m_text[20];
k2400Ptr smu = dev->device;
double absmax;
k2400_GetMachineStatus (dev);
k2400_GetMeasurementParameters (dev);
//k2400_GetReadings(smu->source->acqchan);
SetCtrlVal (panel, K2400_SOURCE, smu->source->acqchan->reading);
SetCtrlVal (panel, K2400_MEASURE, smu->measure->reading);
SetCtrlVal (panel, K2400_OPERATE, smu->operate);
SetInputMode (panel, K2400_SOURCE, smu->operate);
SetInputMode (panel, K2400_MEASURE, smu->operate);
SetCtrlVal (panel, K2400_SELECT, smu->src.current);
SetCtrlVal (panel, K2400_SENSE, smu->sense);
if (smu->src.current) {
Fmt (s_text, "A"); Fmt (m_text, "V");
} else {
Fmt (s_text, "V"); Fmt (m_text, "A");
}
SetCtrlVal (panel, K2400_SOURCETEXT, s_text);
SetCtrlVal (panel, K2400_MEASURETEXT, m_text);
SetCtrlAttribute (panel, K2400_SOURCE_I_RANGE, ATTR_VISIBLE, smu->src.current);
SetCtrlAttribute (panel, K2400_SOURCE_V_RANGE, ATTR_VISIBLE, !smu->src.current);
if (smu->src.current) {
SetCtrlIndex (panel, K2400_SOURCE_I_RANGE, smu->src.rangeC);
GetCtrlVal (panel, K2400_SOURCE_I_RANGE, &smu->source->max);
} else {
SetCtrlIndex (panel, K2400_SOURCE_V_RANGE, smu->src.rangeV);
GetCtrlVal (panel, K2400_SOURCE_V_RANGE, &smu->source->max);
}
smu->source->min = -smu->source->max;
SetCtrlAttribute (panel, K2400_SOURCE, ATTR_MIN_VALUE, smu->source->min);
SetCtrlAttribute (panel, K2400_SOURCE, ATTR_MAX_VALUE, smu->source->max);
SetCtrlVal (panel, K2400_DELAY, smu->src.delay);
SetCtrlAttribute (panel, K2400_MEAS_I_RANGE, ATTR_VISIBLE, !smu->src.current);
SetCtrlAttribute (panel, K2400_MEAS_V_RANGE, ATTR_VISIBLE, smu->src.current);
SetCtrlVal (panel, K2400_LEVEL, k2400_GetCompLevel (dev));
if (smu->src.current) {
SetCtrlIndex (panel, K2400_MEAS_V_RANGE, smu->meas.range);
GetCtrlVal (panel, K2400_MEAS_V_RANGE, &absmax);
} else {
SetCtrlIndex (panel, K2400_MEAS_I_RANGE, smu->meas.range);
GetCtrlVal (panel, K2400_MEAS_I_RANGE, &absmax);
}
SetCtrlAttribute (panel, K2400_LEVEL, ATTR_MIN_VALUE, -absmax);
SetCtrlAttribute (panel, K2400_LEVEL, ATTR_MAX_VALUE, absmax);
SetCtrlVal (panel, K2400_FILTER, smu->meas.filter);
SetCtrlVal (panel, K2400_INTTIME, smu->meas.inttime);
}
