int ManipulateGraphCallback(int panel, int control, int event, void *callbackData, int eventData1, int eventData2)
{
int handle, index;
channelPtr chan;
double x, y, above, below;
if (event == EVENT_VAL_CHANGED)
{
chan = callbackData;
GetGraphCursor (chanview.p1, CHANVIEW_GRAPH, 1, &x, &y);
SetCtrlVal (chanview.p2, MANIP_INDEX, (int)x);
SetCtrlVal (chanview.p2, MANIP_READING, y);
}
if (event == EVENT_COMMIT)
{
chan = callbackData;
GetGraphCursorIndex (chanview.p1, CHANVIEW_GRAPH, 1, &handle, &index);
GetGraphCursor (chanview.p1, CHANVIEW_GRAPH, 1, &x, &y);
SetCtrlVal (chanview.p2, MANIP_INDEX, index);
SetCtrlVal (chanview.p2, MANIP_READING, y);
if (x == 0) below = 0.0;
else below = chan->readings[(int)x-1];
if (x == (chan->pts-1)) above = 0.0;
else above = chan->readings[(int)x+1];
if (fabs(above - chan->readings[(int)x]) < fabs(below - chan->readings[(int)x]))
SetCtrlAttribute (chanview.p2, MANIP_READING, ATTR_INCR_VALUE,
fabs(above - chan->readings[(int)x])/2);
else
SetCtrlAttribute (chanview.p2, MANIP_READING, ATTR_INCR_VALUE,
fabs(below - chan->readings[(int)x])/2);
}
return 0;
}
/// HIFN disconnect from the ScanController and clear the ClientControl arrays
void disconnectScanController(void)
{
// disconnect the Scan Controller
ScanController_Client_Disconnect();
// clear the Client Control arrays, and re-enable the controls
for (int n = 0; n < gNumClientControls; n++)
{
// re-enable the control
SetCtrlAttribute(gClientControl_Panel[n], gClientControl_Control[n], ATTR_DIMMED, 0);
// free the variable value memory
free(gClientControl_Values[n]);
}
free(gClientControl_Panel);
free(gClientControl_Control);
free(gClientControl_Values);
free(gClientControl_DataType);
free(gClientControl_Updated);
free(gClientControl_RequiresPatternCalculation);
gClientControl_Panel = NULL;
gClientControl_Control = NULL;
gClientControl_Values = NULL;
gClientControl_DataType = NULL;
gClientControl_Updated = NULL;
gClientControl_RequiresPatternCalculation = NULL;
gNumClientControls = 0;
// update the indicator variable for the Client Mode
gClientMode = 0;
// update the label on the Client Mode button
SetCtrlAttribute(TabPage_0, TABPANEL_ClientMode, ATTR_LABEL_TEXT, "__Start Client Mode");
}
/* 配置并弹出信号分析面板 */
void popupPanelForGraph(int pHdl){
int i = getGraphIndex(pHdl, 0); //Need a index to find one of the six graphs.
char title[50];
for(int j=0; j<(READ_LENGTH/24); j++)
tempData[i][j] = resultData[i][j];
Delay(0.1);
for(int z=(READ_LENGTH/24),x = 0; z<(READ_LENGTH/12); z++,x++)
tempData[i][z] = resultData[i][x];
// 从uir文件中加载 信号分析面板
if(PopPanels[i] <=0 ){
if ((PopPanels[i] = LoadPanel(0, "MainPanel.uir", PopupPanel)) < 0)
showError("Load PopupPanel Error!");
DisplayPanel(PopPanels[i]);
PopGraphs[i] = PopupPanel_PopGraph1;
GetPanelAttribute(pHdl, ATTR_TITLE, title);
SetPanelAttribute(PopPanels[i], ATTR_TITLE, title);
SetCtrlAttribute(PopPanels[i], PopGraphs[i], ATTR_GRID_COLOR, plotGridColor);
SetCtrlAttribute(PopPanels[i], PopGraphs[i], ATTR_GRAPH_BGCOLOR, VAL_TRANSPARENT);
//temp SetAxisScalingMode(PopPanels[i], PopGraphs[i], VAL_LEFT_YAXIS, VAL_MANUAL, yAxisRange[0], yAxisRange[1]);
PopGPlots[i] = PlotY(PopPanels[i], PopGraphs[i], tempData[i], READ_LENGTH/12,
VAL_DOUBLE, VAL_THIN_LINE, VAL_EMPTY_SQUARE, VAL_SOLID,1, plotLineColor);
}else{
SetActivePanel(PopPanels[i]);
}
}
int CVICALLBACK pause (int panel, int control, int event,
void *callbackData, int eventData1, int eventData2)
{
switch (event)
{
case EVENT_COMMIT:
if (pause_flag)
{
pause_flag=0;
SetCtrlAttribute (ERG_panel, ERG_panel_pause, ATTR_CMD_BUTTON_COLOR, VAL_RED);
SetCtrlAttribute (ERG_panel, ERG_panel_pause, ATTR_LABEL_TEXT, "Pause");
SRS_flag=2;
SRS_onoff();
}
else
{
pause_flag=1;
SetCtrlAttribute (ERG_panel, ERG_panel_pause, ATTR_CMD_BUTTON_COLOR, VAL_GREEN);
SetCtrlAttribute (ERG_panel, ERG_panel_pause, ATTR_LABEL_TEXT, "Resume");
SRS_flag=0;
SRS_onoff();
}
break;
}
return 0;
}
int CVICALLBACK ConfigCMD (int panel, int control, int event,
void *callbackData, int eventData1, int eventData2)
{
switch (event)
{
case EVENT_COMMIT:
DimAction(1);
WriteLog();
ResetTextBox (panelHandle, PANEL_TEXTBOX, "");
if (ReadConfigFile(BBUCOMMON_CONFIGCMD))
{
if (0==InstallPopup(configHandle))
{
SetPanelAttribute (configHandle, ATTR_TITLE, "CheckCMD");
SetCtrlAttribute (configHandle, CONFIG_BOX, ATTR_ENTER_IS_NEWLINE, 1);
SetCtrlAttribute (configHandle, CONFIG_BOX, ATTR_TEXT_BGCOLOR, VAL_OFFWHITE);
}
}
else
{
SetCtrlVal (panelHandle, PANEL_TEXTBOX, "Read data from cmd.txt error,please check it by manual!\r\n");
}
DimAction(0);
break;
}
return 0;
}
void DimAction(int flag)
{
SetCtrlAttribute (panelHandle, PANEL_OUTPUT, ATTR_DIMMED, flag);
SetCtrlAttribute (panelHandle, PANEL_TAB, ATTR_DIMMED, flag);
/*
SetCtrlAttribute (bbucommonHandle, BBUCOMMON_DOWNLOAD, ATTR_DIMMED, flag);
SetCtrlAttribute (bbucommonHandle, BBUCOMMON_UPLOAD, ATTR_DIMMED, flag);
SetCtrlAttribute (bbucommonHandle, BBUCOMMON_CONFIGCMD, ATTR_DIMMED, flag);
SetCtrlAttribute (bbucommonHandle, BBUCOMMON_SENDCMD, ATTR_DIMMED, flag);
SetCtrlAttribute (bbucommonHandle, BBUCOMMON_ENABLEPORT, ATTR_DIMMED, flag);
SetCtrlAttribute (bbucommonHandle, BBUCOMMON_UPDATEALLPUT, ATTR_DIMMED, flag);
SetCtrlAttribute (rrucommonHandle, RRUCOMMON_ENABLEOPT, ATTR_DIMMED, flag);
SetCtrlAttribute (rrucommonHandle, RRUCOMMON_ENABLEVSWR, ATTR_DIMMED, flag);
SetCtrlAttribute (rrucommonHandle, RRUCOMMON_GETRRULOG, ATTR_DIMMED, flag);
SetCtrlAttribute (customizingHandle, CUSTOM_UPDATENAME, ATTR_DIMMED, flag);
SetCtrlAttribute (customizingHandle, CUSTOM_UPDATEVENDOR, ATTR_DIMMED, flag);
SetCtrlAttribute (customizingHandle, CUSTOM_CHECKSFP, ATTR_DIMMED, flag);
SetCtrlAttribute (customizingHandle, CUSTOM_SEARCHFILE, ATTR_DIMMED, flag);
SetCtrlAttribute (customizingHandle, CUSTOM_RECORDUPTIME, ATTR_DIMMED, flag);
SetCtrlAttribute (customizingHandle, CUSTOM_CHECKUPTIME, ATTR_DIMMED, flag);
SetCtrlAttribute (customizingHandle, CUSTOM_FETCHLOGS, ATTR_DIMMED, flag);
SetCtrlAttribute (customizingHandle, CUSTOM_ANALYZEFILTER, ATTR_DIMMED, flag); */
SetMenuBarAttribute (menubarHandle, MENUBAR_CONFIG, ATTR_DIMMED, flag);
SetMenuBarAttribute (menubarHandle, MENUBAR_HELP, ATTR_DIMMED, flag);
}
int CVICALLBACK Save (int panel, int control, int event,
void *callbackData, int eventData1, int eventData2)
{
char *value = "";
switch (event)
{
case EVENT_COMMIT:
value = (char*)malloc(50);
memset(value,0,50);
GetPanelAttribute (configHandle, ATTR_TITLE, value);
if (strcmp("CheckBBUIP", value)==0)
{
if(1==WriteConfig(MENUBAR_CONFIG_CONFIGIP))
{
SetCtrlAttribute (configHandle, CONFIG_BOX, ATTR_TEXT_BGCOLOR, VAL_OFFWHITE);
SetCtrlAttribute (configHandle, CONFIG_BOX, ATTR_CTRL_MODE, VAL_INDICATOR);
SetCtrlVal (panelHandle, PANEL_TEXTBOX, "Save bbuip.txt successfully!\r\n");
}
}
if (strcmp("CheckCMD", value)==0)
{
if(1==WriteConfig(BBUCOMMON_CONFIGCMD))
{
SetCtrlAttribute (configHandle, CONFIG_BOX, ATTR_TEXT_BGCOLOR, VAL_OFFWHITE);
SetCtrlAttribute (configHandle, CONFIG_BOX, ATTR_CTRL_MODE, VAL_INDICATOR);
SetCtrlVal (panelHandle, PANEL_TEXTBOX, "Save command.txt successfully!\r\n");
}
}
free(value);
break;
}
return 0;
}
void das1602Operate (int menubar, int menuItem, void *callbackData, int panel)
{
MCCdevPtr dev = callbackData;
das1602Ptr das = dev->device;
acqchanPtr acqchan;
int i, x = 0, m;
if(!das->panel)
{
das->panel = LoadPanel(utilG.p, "DAS-1602u.uir", DAS_CTRL);
das->menu = LoadMenuBar(das->panel, "DAS-1602u.uir", DASMENU);
SetPanelMenuBar(das->panel, das->menu);
for(i = 0; i < 8; i ++)
{
SetMenuBarAttribute (das->menu, das->Achannels[i]->menuitem_id, ATTR_CALLBACK_DATA, das->Achannels[i]);
SetMenuBarAttribute (das->menu, das->Achannels[i]->menuitem_id, ATTR_ITEM_NAME, das->Achannels[i]->port.analogueIOport.IO.acqchan->channel->label);
SetMenuBarAttribute (das->menu, das->Achannels[i]->menuitem_id, ATTR_CHECKED, das->Achannels[i]->port.analogueIOport.IO.acqchan->acquire);
}
SetMenuBarAttribute (das->menu, DASMENU_SOURCE_DAC1, ATTR_CALLBACK_DATA, das->Achannels[8]->port.analogueIOport.IO.source);
SetMenuBarAttribute (das->menu, DASMENU_SOURCE_DAC2, ATTR_CALLBACK_DATA, das->Achannels[9]->port.analogueIOport.IO.source);
SetMenuBarAttribute (das->menu, DASMENU_SOURCE_DAC1, ATTR_ITEM_NAME, das->Achannels[8]->port.analogueIOport.IO.source->acqchan->channel->label);
SetMenuBarAttribute (das->menu, DASMENU_SOURCE_DAC2, ATTR_ITEM_NAME, das->Achannels[9]->port.analogueIOport.IO.source->acqchan->channel->label);
SetCtrlAttribute (das->panel, DAS_CTRL_RANGE, ATTR_DIMMED, 1);
SetCtrlAttribute (das->panel, DAS_CTRL_ACQ, ATTR_DIMMED, 1);
SetCtrlAttribute (das->panel, DAS_CTRL_INPUT, ATTR_CALLBACK_DATA, das->Achannels[0]);
SetPanelAttribute (das->panel, ATTR_CALLBACK_DATA, das);
}
SetMenuBarAttribute(menubar, menuItem, ATTR_DIMMED, 1);
devPanel_Add (das->panel, dev, das1602_UpdateReadings);
DisplayPanel(das->panel);
}
void utilG_Init (void (*DiscardPanels)(void))
{
int p, control, top, height, width;
int grw, chw, asw, acw;
utilG.acq.pt = 0;
utilG.acq.nPts = 0;
utilG.acq.status = ACQ_NONE;
utilG.p = LoadPanel (0, "utilu.uir", BG);
utilG.DiscardPanels = DiscardPanels;
SetPanelAttribute (utilG.p, ATTR_WINDOW_ZOOM, VAL_MAXIMIZE);
DisplayPanel (utilG.p);
GetCtrlAttribute(utilG.p, BG_GRAPHS, ATTR_WIDTH, &grw);
GetCtrlAttribute(utilG.p, BG_CHANNELS, ATTR_WIDTH, &chw);
GetCtrlAttribute(utilG.p, BG_ACQSETUP, ATTR_WIDTH, &asw);
GetCtrlAttribute(utilG.p, BG_ACQCHANNELS, ATTR_WIDTH, &acw);
GetPanelAttribute(utilG.p, ATTR_WIDTH, &width);
SetCtrlAttribute(utilG.p, BG_GRAPHS, ATTR_LEFT, (3*width/20) - grw);
SetCtrlAttribute(utilG.p, BG_CHANNELS, ATTR_LEFT, (7*width/20) - chw);
SetCtrlAttribute(utilG.p, BG_ACQSETUP, ATTR_LEFT, (9*width/15) - asw);
SetCtrlAttribute(utilG.p, BG_ACQCHANNELS, ATTR_LEFT, (9*width/10) - acw);
initP = LoadPanel (utilG.p, "utilu.uir", INIT);
SetPanelPos (initP, VAL_AUTO_CENTER, VAL_AUTO_CENTER);
SetCtrlAttribute (initP, INIT_TEXT, ATTR_VISIBLE, FALSE);
DisplayPanel (initP);
GetUserEvent (1, &p, &control);
switch (control) {
case INIT_CONTROL: utilG.acq.status = ACQ_DONE; break;
case INIT_ANALYSIS: utilG.acq.status = ACQ_NONE; break;
case INIT_EXIT:
utilG_Exit();
QuitUserInterface(0);
exit (EXIT_SUCCESS);
break;
}
SetMouseCursor (VAL_HOUR_GLASS_CURSOR);
SetCtrlAttribute (initP, INIT_TEXT, ATTR_VISIBLE, TRUE);
SetCtrlAttribute (initP, INIT_TEXT_10, ATTR_VISIBLE, FALSE);
SetCtrlAttribute (initP, INIT_CONTROL, ATTR_VISIBLE, FALSE);
SetCtrlAttribute (initP, INIT_ANALYSIS, ATTR_VISIBLE, FALSE);
SetCtrlAttribute (initP, INIT_EXIT, ATTR_VISIBLE, FALSE);
GetCtrlAttribute (initP, INIT_TEXT, ATTR_TOP, &top);
GetCtrlAttribute (initP, INIT_TEXT, ATTR_HEIGHT, &height);
SetPanelAttribute (initP, ATTR_HEIGHT, top+height+6);
util_ChangeInitMessage ("DAAS Utilities...");
}
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;
}
static void k2400_UpdateReadings (int panel, void *dev)
{
gpibioPtr my_dev = dev;
k2400Ptr smu = my_dev->device;
acqchanPtr acqchan = smu->source->acqchan;
short statusbyte;
char rsp[256];
int control, dim, bg, mode, m;
if (smu->operate) {
if (utilG.acq.status == ACQ_BUSY)
Delay(.05);
if (!util_TakingData() || !(smu->source->acqchan->acquire || smu->measure->acquire)) {
gpibio_GetStatusByte (dev, &statusbyte);
if (statusbyte & K2400_SRE_READINGDONE)
{
//k2400_In (dev, rsp);
//Scan (rsp, "%s>%f,%f", &smu->source->acqchan->reading,
// &smu->measure->reading);
}
//if (statusbyte & K2400_SRE_READYFORTRIGGER)
//k2400_Out (dev, "H0X", .02);
}
time(&present);
if(difftime(present, past) >= delay)
{
k2400_GetReadings(acqchan);
time(&past);
}
//if (expG.acqstatus != utilG.acq.status)
{
m = GetPanelMenuBar (panel);
dim = (util_TakingData() && smu->source->inlist &&
(utilG.exp == EXP_SOURCE));
if (dim) { mode = VAL_INDICATOR; bg = VAL_PANEL_GRAY;}
else { mode = VAL_HOT; bg = VAL_WHITE;}
SetCtrlAttribute (panel, K2400_SOURCE, ATTR_CTRL_MODE, mode);
SetCtrlAttribute (panel, K2400_SOURCE, ATTR_TEXT_BGCOLOR, bg);
SetInputMode (panel, K2400_OPERATE, !dim);
SetInputMode (panel, K2400_SELECT, !dim);
SetInputMode (panel, K2400_SENSE, !dim);
SetMenuBarAttribute (m, K2400MENUS_FILE_LOAD, ATTR_DIMMED, dim);
}
k2400_CheckforProblems (my_dev);
SetCtrlVal (panel, K2400_OVERLIMIT, smu->overLimit);
control = GetActiveCtrl (panel);
if (util_TakingData() || (control != K2400_SOURCE))
SetCtrlVal (panel, K2400_SOURCE, smu->source->acqchan->reading);
SetCtrlVal (panel, K2400_MEASURE, smu->measure->reading);
}
}
void UpdateBarTitle ( int hProgressHandle , int iBarNumber , char* szBarTitle )
{
if ( hProgressHandle < 1 )
return;
if ( szBarTitle == NULL )
return;
switch (iBarNumber)
{
case 1: SetCtrlAttribute ( hProgressHandle , PROGRESS_BAR_1 , ATTR_LABEL_TEXT , szBarTitle ); break;
case 2: SetCtrlAttribute ( hProgressHandle , PROGRESS_BAR_2 , ATTR_LABEL_TEXT , szBarTitle ); break;
case 3: SetCtrlAttribute ( hProgressHandle , PROGRESS_BAR_3 , ATTR_LABEL_TEXT , szBarTitle ); break;
case 4: SetCtrlAttribute ( hProgressHandle , PROGRESS_BAR_4 , ATTR_LABEL_TEXT , szBarTitle ); break;
case 5: SetCtrlAttribute ( hProgressHandle , PROGRESS_BAR_5 , ATTR_LABEL_TEXT , szBarTitle ); break;
case 6: SetCtrlAttribute ( hProgressHandle , PROGRESS_BAR_6 , ATTR_LABEL_TEXT , szBarTitle ); break;
case 7: SetCtrlAttribute ( hProgressHandle , PROGRESS_BAR_7 , ATTR_LABEL_TEXT , szBarTitle ); break;
case 8: SetCtrlAttribute ( hProgressHandle , PROGRESS_BAR_8 , ATTR_LABEL_TEXT , szBarTitle ); break;
case 9: SetCtrlAttribute ( hProgressHandle , PROGRESS_BAR_9 , ATTR_LABEL_TEXT , szBarTitle ); break;
default: break;
}
ProcessDrawEvents();
}
void usb1208ls_MenuCallback(int menubar, int menuItem, void *callbackData, int panel)
{
switch (menuItem)
{
case USBMENU_MEAS_IN_0:
case USBMENU_MEAS_IN_1:
case USBMENU_MEAS_IN_2:
case USBMENU_MEAS_IN_3:
if(utilG.acq.status != ACQ_BUSY){
portPtr port = callbackData;
MCCdevPtr dev = port->port.analogueIOport.IO.acqchan->dev;
usb1208lsPtr pmd = dev->device;
port->measPanel = port->measPanel? port->measPanel : LoadPanel(utilG.p, "USB-1208LSu.uir", MEASURE);
SetCtrlAttribute (port->measPanel, MEASURE_RANGE, ATTR_CALLBACK_DATA, port->port.analogueIOport.IO.acqchan);
SetCtrlAttribute (port->measPanel, MEASURE_LABEL, ATTR_CALLBACK_DATA, port->port.analogueIOport.IO.acqchan);
SetCtrlAttribute (port->measPanel, MEASURE_COEFF, ATTR_CALLBACK_DATA, port->port.analogueIOport.IO.acqchan);
SetCtrlAttribute (port->measPanel, MEASURE_NOTE, ATTR_CALLBACK_DATA, port->port.analogueIOport.IO.acqchan);
SetCtrlAttribute (port->measPanel, MEASURE_ACQ, ATTR_CALLBACK_DATA, port->port.analogueIOport.IO.acqchan);
SetPanelAttribute (port->measPanel, ATTR_TITLE, port->port.analogueIOport.IO.acqchan->channel->label);
SetCtrlVal (port->measPanel, MEASURE_LABEL, port->port.analogueIOport.IO.acqchan->channel->label);
SetCtrlVal (port->measPanel, MEASURE_RANGE, port->port.analogueIOport.range);
SetCtrlVal (port->measPanel, MEASURE_COEFF, port->port.analogueIOport.IO.acqchan->coeff);
SetCtrlVal (port->measPanel, MEASURE_NOTE, port->port.analogueIOport.IO.acqchan->note);
SetCtrlVal (port->measPanel, MEASURE_ACQ, port->port.analogueIOport.IO.acqchan->acquire);
DisplayPanel (port->measPanel);
}
break;
case USBMENU_SOURCE_DAC1:
case USBMENU_SOURCE_DAC2:
case USBMENU_SOURCE_DAC3:
{
sourcePtr src = callbackData;
switch(utilG.exp)
{
case EXP_SOURCE: source_InitPanel(src); break;
case EXP_FLOAT : gensrc_InitPanel(src); break;
}
}
break;
case USBMENU_SOURCE_DAC4:
{
portPtr port = callbackData;
boards_DigitalSourceInit(port);
}
break;
case USBMENU_FILE_SAVE:
boards_Save(callbackData, usb1208ls_Save);
break;
case USBMENU_FILE_LOAD:
boards_Load(callbackData, usb1208ls_Load);
break;
}
}
/*****************************************************************************
.
. Función C: CAN_DibujarEtiqueta
. Responsable: César Armando Cruz Mendoza
. Descripcion: Dibuja la leyenda en la posicion indicada
. Parámetro de entrada: int x | coordenada x de la marca
. int y | coordenada y de la marca
. char *pcCadena | cadena que se desea dibujar
. Parámetro de salida: cero
. Fecha de creación: 18 de Febrero de 2011
.
*****************************************************************************/
int CAN_DibujarEtiqueta(int x, int y, char *pcCadena, int color)
{
SetCtrlAttribute (iPanelCanvas, iControlCanvas, ATTR_PEN_COLOR,
color);
SetCtrlAttribute (iPanelCanvas, iControlCanvas, ATTR_PEN_FILL_COLOR,
VAL_TRANSPARENT);
CreateMetaFont ("Sincros01", VAL_APP_META_FONT, 14, 1, 0, 0, 0);
CanvasDrawText (iPanelCanvas, iControlCanvas, pcCadena,
"Sincros01", MakeRect (y+5, x+5, 20, 20), VAL_CENTER);
return 0;
}
/* 辅助函数-初始化六个子面板及各个面板上的内容 */
void initChildPanels(void){
/* 循环创建六个Panel */
CPanels[0] = createChildPanel("xAxls-Accelerator", 0);
CPanels[1] = createChildPanel("yAxls-Accelerator", 1);
CPanels[2] = createChildPanel("zAxls-Accelerator", 2);
CPanels[3] = createChildPanel("xAxls-Gyro", 3);
CPanels[4] = createChildPanel("yAxls-Gyro", 4);
CPanels[5] = createChildPanel("zAxls-Gyro", 5);
for(int i = 0; i<validMonNum; i++){
DisplayPanel (CPanels[i]);
}
//在子Panel上创建图表，设置Graph属性，准备显示数据
for(int i=0; i<validMonNum; i++){
PGraphs[i] = NewCtrl(CPanels[i], CTRL_STRIP_CHART, 0, 0,0);
SetCtrlAttribute(CPanels[i], PGraphs[i], ATTR_WIDTH, cWidth);
SetCtrlAttribute(CPanels[i], PGraphs[i], ATTR_HEIGHT, cHeight);
SetCtrlAttribute(CPanels[i], PGraphs[i], ATTR_PLOT_BGCOLOR, plotBakgColor);
SetCtrlAttribute(CPanels[i], PGraphs[i], ATTR_GRID_COLOR, plotGridColor);
SetCtrlAttribute(CPanels[i], PGraphs[i], ATTR_EDGE_STYLE, VAL_FLAT_EDGE);
SetCtrlAttribute(CPanels[i], PGraphs[i], ATTR_SCROLL_MODE, VAL_CONTINUOUS);
SetAxisScalingMode(CPanels[i], PGraphs[i], VAL_LEFT_YAXIS, graphScaleMode, yAxisRange[0], yAxisRange[1]);
SetCtrlAttribute(CPanels[i], PGraphs[i], ATTR_POINTS_PER_SCREEN, 50);
//SetCtrlAttribute(CPanels[i], PGraphs[i], ATTR_YFORMAT,VAL_FLOATING_PT_FORMAT);
SetTraceAttribute(CPanels[i],PGraphs[i], 1, ATTR_TRACE_COLOR, plotLineColor);
//SetTraceAttribute(CPanels[i],PGraphs[i], 1, ATTR_PLOT_STYLE, VAL_CONNECTED_POINTS);
SetCtrlAttribute(CPanels[i], PGraphs[i], ATTR_ANTI_ALIASED_PLOTS, 1);
}
manageGraphCallbackFunc();
}
/*****************************************************************************
.
. Función C: PRE_IniciarCatTransmisiones
. Responsable: César Armando Cruz Mendoza
. Descripcion: Una vez que el usuario ha solicitado mostrar el
. catalogo de transmisiones, se despliega en pantalla
. Parámetro de entrada: ninguno
. Parámetro de salida: cero
. Fecha de creación: 06 de Marzo de 2014
.
*****************************************************************************/
int PRE_IniciarCatTransmisiones()
{
PRE_UbicarPanel(iPanelCatTransmisiones);
if (BDS_LeerTransmisiones(iPanelCatTransmisiones, pCatTransm_lstTransmisiones) == TRA_CON_TRANSMISIONES)
{
PRE_CambioTransmision(iPanelCatTransmisiones, pCatTransm_lstTransmisiones);
//habilita las funciones de editar y eliminar
SetCtrlAttribute(iPanelCatTransmisiones, pCatTransm_picEditar, ATTR_DIMMED, 0);
SetCtrlAttribute(iPanelCatTransmisiones, pCatTransm_picEliminar, ATTR_DIMMED, 0);
SetCtrlAttribute(iPanelCatTransmisiones, pCatTransm_picGuardar, ATTR_DIMMED, 1);
SetCtrlAttribute(iPanelCatTransmisiones, pCatTransm_picCancelar, ATTR_DIMMED, 1);
}
else
{
//debe deshabilitar las funciones de editar, eliminar
SetCtrlAttribute(iPanelCatTransmisiones, pCatTransm_picEditar, ATTR_DIMMED, 1);
SetCtrlAttribute(iPanelCatTransmisiones, pCatTransm_picEliminar, ATTR_DIMMED, 1);
SetCtrlAttribute(iPanelCatTransmisiones, pCatTransm_picGuardar, ATTR_DIMMED, 1);
SetCtrlAttribute(iPanelCatTransmisiones, pCatTransm_picCancelar, ATTR_DIMMED, 1);
}
PRE_OpcionActiva(-1);
//PRE_ControlesEntrenamiento(Modo);
//PRE_CondicionesIniciales();
return 0;
}
static void k213_Operate (int menubar, int menuItem, void *callbackData, int panel)
{
int p, m, port, width, height;
gpibioPtr dev = callbackData;
k213Ptr quadsrc = dev->device;
char label[256];
SetMenuBarAttribute (menubar, menuItem, ATTR_DIMMED, TRUE);
p = dev->iPanel? dev->iPanel: LoadPanel (utilG.p, "k213u.uir", K213);
dev->iPanel = p;
Fmt (label, "Keithley 213 : %s", dev->label);
SetPanelAttribute (p, ATTR_TITLE, label);
m = LoadMenuBar (p, "k213u.uir", K213MENUS);
SetPanelMenuBar (p, m);
SetPanelAttribute (p, ATTR_CALLBACK_DATA, dev);
SetMenuBarAttribute (m, K213MENUS_FILE_SAVE, ATTR_CALLBACK_DATA, dev);
SetMenuBarAttribute (m, K213MENUS_FILE_LOAD, ATTR_CALLBACK_DATA, dev);
SetMenuBarAttribute (m, K213MENUS_FILE_GPIB, ATTR_CALLBACK_DATA, dev);
for (port = 0; port < 4; port++) {
quadsrc->port[port].panel = LoadPanel (p, "k213u.uir", K213PORT);
GetPanelAttribute (quadsrc->port[port].panel, ATTR_WIDTH, &width);
GetPanelAttribute (quadsrc->port[port].panel, ATTR_HEIGHT, &height);
SetPanelPos (quadsrc->port[port].panel, 17+2, (port*(width+4))+2);
Fmt (label, "port %i", port+1);
SetCtrlVal (quadsrc->port[port].panel, K213PORT_TITLE, label);
SetCtrlAttribute (quadsrc->port[port].panel, K213PORT_DISPLAY, ATTR_CALLBACK_DATA, dev);
SetCtrlAttribute (quadsrc->port[port].panel, K213PORT_AUTORANGE, ATTR_CALLBACK_DATA, dev);
SetCtrlAttribute (quadsrc->port[port].panel, K213PORT_RANGE, ATTR_CALLBACK_DATA, dev);
SetCtrlAttribute (quadsrc->port[port].panel, K213PORT_SETUP, ATTR_CALLBACK_DATA, dev);
SetPanelAttribute(quadsrc->port[port].panel, ATTR_CALLBACK_DATA, dev);
DisplayPanel (quadsrc->port[port].panel);
}
SetPanelAttribute (p, ATTR_WIDTH, (width+4)*port);
SetPanelAttribute (p, ATTR_HEIGHT, height+4+17);
SetPanelPos (p, VAL_AUTO_CENTER, VAL_AUTO_CENTER);
k213_UpdateControls (p, dev);
devPanel_Add (p, dev, k213_UpdateReadings);
DisplayPanel (p);
}
int ManipulateSelectionCallback(int panel, int control, int event, void *callbackData, int eventData1, int eventData2)
{
int i;
channelPtr chan;
if (event == EVENT_COMMIT)
{
GetCtrlVal (panel, control, &i);
chan = channellist_GetItem (i);
channel_UpdateViewPanel (chan);
SetCtrlAttribute (chanview.p1, CHANVIEW_GRAPH, ATTR_CALLBACK_DATA, chan);
SetCtrlAttribute (chanview.p2, MANIP_READING, ATTR_CALLBACK_DATA, chan);
}
return 0;
}
int CVICALLBACK Edit (int panel, int control, int event,
void *callbackData, int eventData1, int eventData2)
{
switch (event)
{
case EVENT_COMMIT:
if (0==SetCtrlAttribute (configHandle, CONFIG_BOX, ATTR_CTRL_MODE, VAL_HOT))
{
SetCtrlAttribute (configHandle, CONFIG_BOX, ATTR_TEXT_BGCOLOR, VAL_WHITE);
SetCtrlVal (panelHandle, PANEL_TEXTBOX, "You can edit bbuip box now...!\r\n");
}
break;
}
return 0;
}
void initRobotPanel(int panel, int rid)
{
ROBOT* rb = &sys->rb[rid];
curRobotId = rid;
curRid = rb->firstRid;
char* title[] = {"前段-製程槽","中段-製程槽","後段-製程槽"};
SetCtrlAttribute(panel,PANEL_RB_TEXTMSG_22, ATTR_CTRL_VAL, title[rid]);
for(int i = rb->firstRid; i <= rb->lastRid; i++)
{
//InsertListItem(panel, PANEL_RB_RING, i - rb->firstRid, sys->tk[sys->rtk[i].tid].name, i);
char tmp[32];
if(i <= rb->lastRid-1 && sys->rtk[i].tid == sys->rtk[i+1].tid)
{
sprintf(tmp,"%s-1", sys->tk[sys->rtk[i].tid].name);
InsertListItem(panel, PANEL_RB_RING, i - rb->firstRid, tmp, i);
i++;
sprintf(tmp,"%s-2", sys->tk[sys->rtk[i].tid].name);
InsertListItem(panel, PANEL_RB_RING, i - rb->firstRid, tmp, i);
}
else
InsertListItem(panel, PANEL_RB_RING, i - rb->firstRid, sys->tk[sys->rtk[i].tid].name, i);
}
if(curRobotId == RB01)
{
SetCtrlAttribute(panel,PANEL_RB_CMD_CLEAN, ATTR_VISIBLE, 1);
InsertListItem(panel, PANEL_RB_RING, rb->lastRid - rb->firstRid + 1, "Clean", rb->lastRid + 1);
SetCtrlVal(panel, PANEL_RB_UNLOCKX, sys->rtk[rb->firstRid].MvPosH / 10000);
SetCtrlVal(panel, PANEL_RB_UNLOCKY, sys->rtk[rb->firstRid].MvPosV / 10000);
SetCtrlVal(panel, PANEL_RB_LOCKX, sys->rtk[rb->firstRid].MvLock / 10000);
SetCtrlVal(panel, PANEL_RB_LOCKY, sys->rtk[rb->firstRid].MvPosV / 10000);
}
else
{
SetCtrlVal(panel, PANEL_RB_UNLOCKX, sys->rtk[rb->firstRid].MvPosH2 / 10000);
SetCtrlVal(panel, PANEL_RB_UNLOCKY, sys->rtk[rb->firstRid].MvPosV2 / 10000);
SetCtrlVal(panel, PANEL_RB_LOCKX, sys->rtk[rb->firstRid].MvLock2 / 10000);
SetCtrlVal(panel, PANEL_RB_LOCKY, sys->rtk[rb->firstRid].MvPosV2 / 10000);
}
SetCtrlVal(panel, PANEL_RB_SAV_HI, rb->safeHight / 10000);
SetCtrlAttribute(panel,PANEL_RB_CMD_PUT, ATTR_VISIBLE, 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");
}
/*****************************************************************************
.
. Función C: CAN_InfoControl
. Responsable: César Armando Cruz Mendoza
. Descripcion: Dibuja la marca solicitada en el canvas del panel
. Parámetro de entrada: int x | coordenada x de la marca
. int y | coordenada y de la marca
. Parámetro de salida: cero
. Fecha de creación: 18 de Febrero de 2011
.
*****************************************************************************/
int CAN_DibujarMarca(int x, int y, int color)
{
SetCtrlAttribute (iPanelCanvas, iControlCanvas, ATTR_PEN_FILL_COLOR,
color);
CanvasDrawOval (iPanelCanvas, iControlCanvas, MakeRect (y, x, 30, 30),
VAL_DRAW_INTERIOR);
/*
VAL_LT_GRAY
VAL_DK_YELLOW
VAL_OFFWHITE
VAL_DK_MAGENTA
VAL_DK_CYAN
VAL_DK_GREEN
VAL_DK_RED
VAL_MAGENTA
VAL_GREEN
VAL_BLUE
VAL_CYAN
VAL_RED
VAL_YELLOW
VAL_DK_BLUE
VAL_BLACK
VAL_GRAY
VAL_TRANSPARENT
VAL_PANEL_GRAY
VAL_DK_GRAY
VAL_WHITE
*/
return 0;
}
void util_InitClose (int panel, int control, int visible)
{
SetPanelAttribute (panel, ATTR_CLOSE_CTRL, control);
SetPanelAttribute (panel, ATTR_SYSTEM_MENU_VISIBLE, TRUE);
SetPanelAttribute (panel, ATTR_CLOSE_ITEM_VISIBLE, TRUE);
SetCtrlAttribute (panel, control, ATTR_VISIBLE, visible);
}
void acquire_Init (void)
{
if (utilG.acq.status != ACQ_NONE) {
util_ChangeInitMessage ("Acquisition Utilities...");
util_WriteLog("acquire_Init()\nStarting...\n");
acqG.p.setup = LoadPanel (utilG.p, "acquireu.uir", ACQSETUP);
//SetPanelPos (acqG.p.setup, VAL_AUTO_CENTER, VAL_AUTO_CENTER);
// Set default data dir and suffix
int dirNameLen;
if(FileExists(DFLT_DATA_DIR, &dirNameLen) ) {
strcpy(dataFile.dataDir, DFLT_DATA_DIR);
} else {
char msg[MAX_PATHNAME_LEN*2];
sprintf(msg, "Default Data Does not exist:\n%s\nUsing application dir.", DFLT_DATA_DIR);
MessagePopup ("Acquisition Setup", msg );
GetProjectDir (dataFile.dataDir);
}
SetCtrlVal (acqG.p.setup, ACQSETUP_DATADIR, dataFile.dataDir);
strcpy(dataFile.fileSuffix, DFLT_FILE_SUFFIX);
SetCtrlVal(acqG.p.setup, ACQSETUP_FILESUFFIX, dataFile.fileSuffix);
// This control is a button on startup panel, "control. acquisition, and analysis"
InstallCtrlCallback (utilG.p, BG_ACQSETUP, AcqSetupCallback, 0);
} else SetCtrlAttribute (utilG.p, BG_ACQSETUP, ATTR_VISIBLE, FALSE);
}
int main (int argc, char *argv[])
{
if (InitCVIRTE (0, argv, 0) == 0)
return -1; /* out of memory */
if ((pBasicFn = LoadPanel (0, "UIRBasicFnct.uir", P_BASIC_FN)) < 0)
return -1;
if ((pSystem = LoadPanel (0, "UIRSystem.uir", P_SYSTEM)) < 0)
return -1;
if ((pControlPad = LoadPanel (0, "UIRControlPad.uir", P_CTRL_PAD)) < 0)
return -1;
GetCtrlVal (pBasicFn, P_BASIC_FN_SWH_FNCT_MODE, &iFnctMode);
GetCtrlVal (pBasicFn, P_BASIC_FN_SWH_DISPLAY_MODE, &iDispMode);
GetCtrlVal (pBasicFn, P_BASIC_FN_SWH_DISPLAY_LAST_FIVE, &iLastFive);
GetCtrlVal (pBasicFn, P_BASIC_FN_SWITCH_SENSOR, &iSwitchSens);
GetCtrlVal (pBasicFn, P_BASIC_FN_SWITCH_DREH_MODE, &iDrehMode);
SetCtrlAttribute (pSystem, P_SYSTEM_CMD_DEINIT, ATTR_DIMMED, 1);
DisplayPanel (pBasicFn);
RunUserInterface ();
DiscardPanel (pBasicFn);
return 0;
}
int loadprojects()
{
int i,j,resCode;
char Tag[32] = "";
// SetWindowText("打开项目");
SetPanelAttribute(panel_open,ATTR_TITLE,"打开项目");
SetCtrlAttribute(panel_open,OPPANEL_TREE_ProjectList,ATTR_LABEL_TEXT,"测试项目列表");
ClearListCtrl(panel_open, OPPANEL_TREE_ProjectList);
SetTreeColumnAttribute(panel_open,OPPANEL_TREE_ProjectList,0,ATTR_LABEL_TEXT,"测试项目名称");
SetTreeColumnAttribute(panel_open,OPPANEL_TREE_ProjectList,1,ATTR_LABEL_TEXT,"项目创建日期");
SetTreeColumnAttribute(panel_open,OPPANEL_TREE_ProjectList,2,ATTR_LABEL_TEXT,"项目创建时间");
SetTreeColumnAttribute(panel_open,OPPANEL_TREE_ProjectList,3,ATTR_LABEL_TEXT,"已有测量组数");
SetTreeColumnAttribute(panel_open,OPPANEL_TREE_ProjectList,0,ATTR_COLUMN_WIDTH,125);
SetTreeColumnAttribute(panel_open,OPPANEL_TREE_ProjectList,1,ATTR_COLUMN_WIDTH,80);
SetTreeColumnAttribute(panel_open,OPPANEL_TREE_ProjectList,2,ATTR_COLUMN_WIDTH,80);
SetTreeColumnAttribute(panel_open,OPPANEL_TREE_ProjectList,3,ATTR_COLUMN_WIDTH,80);
for (i = 0; i < projectlist.number; i++)
{
j = InsertTreeItem(panel_open,OPPANEL_TREE_ProjectList,VAL_SIBLING,i-1,VAL_LAST,projectlist.projects[i].TestTaskName,projectlist.projects[i].TestTaskName,Tag,i+1);
resCode = SetTreeCellAttribute(panel_open,OPPANEL_TREE_ProjectList,j,1,ATTR_LABEL_TEXT,projectlist.projects[i].TestCreateDate.DateSTR);
resCode = SetTreeCellAttribute(panel_open,OPPANEL_TREE_ProjectList,j,2,ATTR_LABEL_TEXT,projectlist.projects[i].TestCreateTime.TimeSTR);
char buffer[BUFFERLEN] = "";
sprintf(buffer,"%d",projectlist.projects[i].TestedGroupNumber);
resCode = SetTreeCellAttribute(panel_open,OPPANEL_TREE_ProjectList,j,3,ATTR_LABEL_TEXT,buffer);
// MessagePopup("",Tag);
}
state_open = 1;
return 0;
}
/// HIFN Toggle the client mode, i.e. transfer control between the GUI and the Scan Controller (remote program)
int CVICALLBACK ClientMode_Callback (int panel, int control, int event,
void *callbackData, int eventData1, int eventData2)
{
switch (event)
{
case EVENT_COMMIT:
// are we in Client Mode?
if (gClientMode)
{
// yes, stop client mode
disconnectScanController();
}
else
{
// no, start client mode
if (ScanController_Client_Connect(ScanController_clienttype_hw, "SLM", ScanController_Callback , NULL, disconnectScanController, 1))
{
// register variables on server
registerClientModeControls();
// update the indicator variable
gClientMode = 1;
// update the label on the button
SetCtrlAttribute(panel, control, ATTR_LABEL_TEXT, "__Stop Client Mode");
}
}
break;
}
return 0;
}
int SR844RefCallback(int panel, int control, int event, void *callbackData, int eventData1, int eventData2)
{
gpibioPtr dev = callbackData;
double r;
char cmd[256];
switch (control) {
case SR844_REF_FREQ:
if (event == EVENT_VAL_CHANGED) {
GetCtrlVal (panel, control, &r);
Fmt (cmd, "FREQ%f", r);
gpibio_Out (dev, cmd);
r = sr844_GetDoubleVal (dev, "FREQ?");
SetCtrlVal (panel, control, r);
SetCtrlAttribute (panel, control, ATTR_INCR_VALUE, r/10);
}
break;
case SR844_REF_PHASE:
if (event == EVENT_VAL_CHANGED) {
GetCtrlVal (panel, control, &r);
Fmt (cmd, "PHAS%f", r);
gpibio_Out (dev, cmd);
SetCtrlVal (panel, control, sr844_GetDoubleVal(dev, "PHAS?"));
}
break;
}
return 0;
}
//---------------------------------------------------------
// инициализация ЦАП
//---------------------------------------------------------
void InitDac(int Pnl)
{
// запретим работу АЦП
if(!ENABLE_ADC_PLX(&bi[0], 0))
{
DefaultCtrl(Pnl, P(BOX));
SetCtrlVal(Pnl, P(BOX), " Не выполнена функция ENABLE_ADC_PLX()!");
SetMenuBarAttribute(B(ADC), ATTR_MENU_BAR_ENABLED, DISABLE);
return;
}
// запретим работу ЦАП
if(!ENABLE_DAC_STREAM_PLX(&bi[0], 0))
{
DefaultCtrl(Pnl, P(BOX));
SetCtrlVal(Pnl, P(BOX), " Не выполнена функция ENABLE_DAC_STREAM_PLX()!");
SetMenuBarAttribute(B(DAC), ATTR_MENU_BAR_ENABLED, DISABLE);
SetCtrlAttribute(Pnl, P(START), ATTR_CTRL_ENABLED, DISABLE);
return;
}
// отконфигурируем FIFO буфер ЦАП
if(!DAC_FIFO_CONFIG_PLX(&bi[0], 1024))
{
DefaultCtrl(Pnl, P(BOX));
SetCtrlVal(Pnl, P(BOX), " Не выполнена функция DAC_FIFO_CONFIG_PLX()!");
SetMenuBarAttribute(B(DAC), ATTR_MENU_BAR_ENABLED, DISABLE);
SetCtrlAttribute(Pnl, P(START), ATTR_CTRL_ENABLED, DISABLE);
return;
}
DacFifoBaseAddress=GET_DM_WORD_PLX(&bi[0], L_DAC_FIFO_BASE_ADDRESS_PLX);
DacFifoLength=GET_DM_WORD_PLX(&bi[0], L_DAC_FIFO_LENGTH_PLX);
// установим частоту работы ЦАП
if(!SET_DAC_RATE_PLX(&bi[0], &DAC_Rate))
{
DefaultCtrl(Pnl, P(BOX));
SetCtrlVal(Pnl, P(BOX), " Не выполнена функция SET_DAC_RATE_PLX()!");
SetMenuBarAttribute(B(DAC), ATTR_MENU_BAR_ENABLED, DISABLE);
SetCtrlAttribute(Pnl, P(START), ATTR_CTRL_ENABLED, DISABLE);
return;
}
else
SetCtrlVal(Pnl, P(DAC_RATE), DAC_Rate);
}
static void k213_UpdateControls (int panel, gpibioPtr dev)
{
k213Ptr quadsrc = dev->device;
int port;
k213_GetStatus (dev);
for (port = 0; port < 4; port++) {
SetCtrlVal (quadsrc->port[port].panel, K213PORT_DISPLAY, quadsrc->port[port].src->acqchan->reading);
SetCtrlVal (quadsrc->port[port].panel, K213PORT_AUTORANGE, quadsrc->port[port].autorange);
SetCtrlVal (quadsrc->port[port].panel, K213PORT_RANGE, quadsrc->port[port].range);
SetInputMode (quadsrc->port[port].panel, K213PORT_RANGE, !quadsrc->port[port].autorange);
if (quadsrc->port[port].autorange || (quadsrc->port[port].range == 3)) {
quadsrc->port[port].src->min = -10.0;
quadsrc->port[port].src->max = 10.0;
} else {
switch (quadsrc->port[port].range) {
case 0:
quadsrc->port[port].src->min = -0.0;
quadsrc->port[port].src->max = 0.0;
break;
case 1:
quadsrc->port[port].src->min = -1.0;
quadsrc->port[port].src->max = 1.0;
break;
case 2:
quadsrc->port[port].src->min = -5.0;
quadsrc->port[port].src->max = 5.0;
break;
}
}
if (quadsrc->port[port].autorange)
{
quadsrc->port[port].src->ranges.autoscale = 1;
quadsrc->port[port].src->ranges.temprange = quadsrc->range;
}
else
{
quadsrc->port[port].src->ranges.autoscale = 0;
quadsrc->port[port].src->ranges.temprange[0] = quadsrc->range[quadsrc->port[port].range];
}
SetCtrlAttribute (quadsrc->port[port].panel, K213PORT_DISPLAY, ATTR_MIN_VALUE, quadsrc->port[port].src->min);
SetCtrlAttribute (quadsrc->port[port].panel, K213PORT_DISPLAY, ATTR_MAX_VALUE, quadsrc->port[port].src->max);
}
}
