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 CVICALLBACK BasicFunctions (int panel, int control, int event,
void *callbackData, int eventData1, int eventData2)
{
double dState;
char sTmp [4096];
switch (event)
{
case EVENT_COMMIT:
switch(control)
{
case P_BASIC_FN_RNG_SHOW_UI:
GetCtrlVal (pBasicFn, P_BASIC_FN_RNG_SHOW_UI, &iCtrlVal);
switch(iCtrlVal)
{
case 0:
DisplayPanel (pSystem);
break;
case 1:
DisplayPanel (pControlPad);
SetCtrlAttribute (pBasicFn, P_BASIC_FN_TIM_DATA, ATTR_ENABLED, 1);
break;
}
}
break;
case EVENT_TIMER_TICK:
switch (control)
{
case P_BASIC_FN_TIM_DATA:
// DebugPrintf ("---> [P_BASIC_FN_TIM_DATA]\n");
PiCardFnct (PI_GET_POS);
GetPiCardScrtItem (PI_POS, 1, &dState);
sprintf (sTmp, "%f", dState);
SetCtrlVal (pControlPad, P_CTRL_PAD_LBL_CURRENT_POS_4, sTmp);
GetPiCardScrtItem (PI_LAST_POS, 1, &dState);
sprintf (sTmp, "%f", dState);
SetCtrlVal (pControlPad, P_CTRL_PAD_LBL_LAST_POS, sTmp);
break;
}
}
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 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;
}
/* 配置并弹出信号分析面板 */
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]);
}
}
/* 辅助函数-初始化六个子面板及各个面板上的内容 */
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();
}
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);
}
int main (int argc, char *argv[])
{
if (InitCVIRTE (0, argv, 0) == 0)
return -1; /* out of memory */
if ((panelHandle = LoadPanel (0, "Remotely.uir", PANEL)) < 0)
return -1;
if ((configHandle = LoadPanel (0, "Remotely.uir", CONFIG)) < 0)
return -1;
if ((itemHandle = LoadPanel (0, "Remotely.uir", FILE_ITEM)) < 0)
return -1;
menubarHandle = GetPanelMenuBar (panelHandle);
GetPanelHandleFromTabPage (panelHandle, PANEL_TAB, 0, &bbucommonHandle);
GetPanelHandleFromTabPage (panelHandle, PANEL_TAB, 1, &rrucommonHandle);
GetPanelHandleFromTabPage (panelHandle, PANEL_TAB, 2, &customizingHandle);
SetActiveTabPage (panelHandle, PANEL_TAB, 0);
if(Initial(0, 0)<0 || Initial(1, 0)<0 || Initial(2, 0)<0 || Initial(3, 0)<0)
{
SetLed("Read file type information from config.ini to UI error,please try again!",0);
}
WriteLog();
DisplayPanel (panelHandle);
RunUserInterface ();
return 0;
}
// ----------------------------------------------------------------------------
int __stdcall WinMain (HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpszCmdLine, int nCmdShow) {
#ifdef _MSC_VER
if (InitCVIRTE (0, 0, 0) == 0) return -1;
#endif // _MSC_VER
CVIProfSetCurrentThreadProfiling (1);
int panelHandle=-1;
if ((panelHandle = LoadPanel (0, "../assets/frontend.uir", PANEL)) < 0) return -1;
DisplayPanel (panelHandle);
RunUserInterface ();
DiscardPanel (panelHandle);
// Not needed
// CVIProfSetCurrentThreadProfiling (0);
{
size_t Bytes;
size_t Blocks;
// View info in Debug Output Window
CVIDynamicMemoryInfo ("", &Blocks, &Bytes, DYNAMIC_MEMORY_SHOW_ALLOCATED_MEMORY_SUMMARY);
}
#ifdef _MSC_VER
_CrtDumpMemoryLeaks();
#endif // _MSC_VER
return 0;
}
void main()
{
int handle, panel, id;
int var;
id = 0;
panel = LoadPanel (0, "primcvi.uir", mipanel1);
DisplayPanel (panel);
while (id != mipanel1_salir)
{
GetUserEvent (0, &handle, &id);
GetCtrlVal (panel, mipanel1_pot1, &var);
SetCtrlVal (panel, mipanel1_tanque1, var);
}
DiscardPanel (panel);
} /* del main */
STD_ERROR DLLEXPORT GRAPH_CreateItem( char *szUIRfilename , int panel_const , int control_const , void **pItemData , unsigned int numberOfPoints , double StartX , double StopX , double MaxY , double MinY , char *szX_AxisName , char *szY_AxisName , int bDisplayGraph , int *piGraphPanelHandle )
{
STD_ERROR StdError = {0};
tsPlotGraphData *pData = NULL;
CALLOC_ERR( pData , 1 , sizeof(tsPlotGraphData));
IF (( pItemData == NULL ) , "Item data can't be NULL");
NO_CHK_STDERR(GRAPH_FreeItem( pItemData , 0 ));
*pItemData = pData;
pData->numberOfTraces = 0;
pData->numberOfPoints = numberOfPoints;
pData->start_x = StartX;
pData->stop_x = StopX;
pData->y_axis_max = MaxY;
pData->y_axis_min = MinY;
if (szUIRfilename != NULL)
{
if ( piGraphPanelHandle && ( *piGraphPanelHandle ))
{
pData->panel = *piGraphPanelHandle;
}
else
{
pData->panel = LoadPanelEx (0, szUIRfilename , panel_const , __CVIUserHInst );
if ( piGraphPanelHandle )
*piGraphPanelHandle = pData->panel;
}
if ( bDisplayGraph )
DisplayPanel( pData->panel );
pData->bExtUse = 0;
}
else
{
pData->panel = panel_const;
pData->bExtUse = 1;
}
pData->control = control_const;
if ( szX_AxisName )
strcpy( pData->szX_AxisName , szX_AxisName );
if ( szY_AxisName )
strcpy( pData->szY_AxisName , szY_AxisName );
Error:
return StdError;
}
int AcqSetupCallback(int panel, int control, int event, void *callbackData, int eventData1, int eventData2)
{
if (event == EVENT_COMMIT) {
acquire_UpdatePanel();
DisplayPanel (acqG.p.setup);
}
return 0;
}
int main (int argc, char *argv[]) {
if (InitCVIRTE (0, argv, 0) == 0)
return -1; /* out of memory */
if ((panelHandle = LoadPanel (0, "HelloWorld.uir", PANEL)) < 0)
return -1;
DisplayPanel (panelHandle);
RunUserInterface ();
DiscardPanel (panelHandle);
return 0;
}
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;
}
}
int main (int argc, char *argv[]){
if (InitCVIRTE (0, argv, 0) == 0)
return -1; /* out of memory */
if ((panelHdl = LoadPanel(0, "MainPanel.uir", MainPanel)) < 0)
return -1;
initVars(); //init variables
DisplayPanel (panelHdl);
RunUserInterface();
cleanGarbage();
return 0;
}
int main (int argc, char *argv[])
{
if (InitCVIRTE (0, argv, 0) == 0)
return -1; /* out of memory */
if ((mypanel = LoadPanel (0, "display_four_signals.uir", MYPANEL)) < 0)
return -1;
DisplayPanel (mypanel);
RunUserInterface ();
DiscardPanel (mypanel);
return 0;
}
/*
int main (int argc, char *argv[])
{
if (InitCVIRTE (0, argv, 0) == 0)
return -1; // out of memory
if ((panel_open = LoadPanel (0, "Panel_OpenProject.uir", OPPANEL)) < 0)
return -1;
DisplayPanel (panel_open);
RunUserInterface ();
DiscardPanel (panel_open);
return 0;
}
*/
int CVICALLBACK OpenProjectCancel (int panel, int control, int event,
void *callbackData, int eventData1, int eventData2)
{
switch (event)
{
case EVENT_COMMIT:
HidePanel (panel_open);
DisplayPanel (panel_main);
break;
}
return 0;
}
void AcqInfoCallback(int menubar, int menuItem, void *callbackData, int panel)
{
if (!acqinfoP) {
acqinfoP = LoadPanel (utilG.p, "acquireu.uir", ACQINFO);
if (acqinfoP < 0) acqinfoP = 0;
else {
SetPanelPos (acqinfoP, VAL_AUTO_CENTER, VAL_AUTO_CENTER);
DisplayPanel (acqinfoP);
}
}
}
int CVICALLBACK SaveSetup (int panel, int control, int event,
void *callbackData, int eventData1, int eventData2)
{
switch (event)
{
case EVENT_COMMIT:
DisplayPanel (panelHandle_calibration);
StackPush(&panel_stack, panel);
HidePanel (panel);
break;
}
return 0;
}
static void OperateK236 (int menubar, int menuItem, void *callbackData, int panel)
{
int p, m;
gpibioPtr dev = callbackData;
k236Ptr smu = dev->device;
char label[256];
SetMenuBarAttribute (menubar, menuItem, ATTR_DIMMED, TRUE);
p = dev->iPanel? dev->iPanel:LoadPanel (utilG.p, "k236u.uir", K236);
dev->iPanel = p;
SetPanelPos (p, VAL_AUTO_CENTER, VAL_AUTO_CENTER);
Fmt (label, "Keithley 236 Source Measure Unit: %s", dev->label);
SetPanelAttribute (p, ATTR_TITLE, label);
m = LoadMenuBar (p, "k236u.uir", K236MENUS);
SetPanelMenuBar (p, m);
SetMenuBarAttribute (m, K236MENUS_FILE_SAVE, ATTR_CALLBACK_DATA, dev);
SetMenuBarAttribute (m, K236MENUS_FILE_LOAD, ATTR_CALLBACK_DATA, dev);
SetMenuBarAttribute (m, K236MENUS_FILE_GPIB, ATTR_CALLBACK_DATA, dev);
SetMenuBarAttribute (m, K236MENUS_SOURCE, ATTR_CALLBACK_DATA, smu->source);
SetMenuBarAttribute (m, K236MENUS_MEASURE, ATTR_CALLBACK_DATA, smu->measure);
SetPanelAttribute (p, ATTR_CALLBACK_DATA, dev);
SetCtrlAttribute (p, K236_SOURCE, ATTR_CALLBACK_DATA, smu->source);
SetCtrlAttribute (p, K236_SOURCE_I_RANGE, ATTR_CALLBACK_DATA, dev);
SetCtrlAttribute (p, K236_SOURCE_V_RANGE, ATTR_CALLBACK_DATA, dev);
SetCtrlAttribute (p, K236_DELAY, ATTR_CALLBACK_DATA, dev);
SetCtrlAttribute (p, K236_IDENTIFY, ATTR_CALLBACK_DATA, dev);
SetCtrlAttribute (p, K236_OPERATE, ATTR_CALLBACK_DATA, dev);
SetCtrlAttribute (p, K236_SELECT, ATTR_CALLBACK_DATA, dev);
SetCtrlAttribute (p, K236_SENSE, ATTR_CALLBACK_DATA, dev);
SetCtrlAttribute (p, K236_MEAS_I_RANGE, ATTR_CALLBACK_DATA, dev);
SetCtrlAttribute (p, K236_MEAS_V_RANGE, ATTR_CALLBACK_DATA, dev);
SetCtrlAttribute (p, K236_LEVEL, ATTR_CALLBACK_DATA, dev);
SetCtrlAttribute (p, K236_FILTER, ATTR_CALLBACK_DATA, dev);
SetCtrlAttribute (p, K236_INTTIME, ATTR_CALLBACK_DATA, dev);
SetCtrlAttribute (p, K236_SUPPRESS, ATTR_CALLBACK_DATA, dev);
k236_UpdateControls (p, dev);
devPanel_Add (p, dev, k236_UpdateReadings);
DisplayPanel (p);
}
int main (int argc, char *argv[])
{
if (InitCVIRTE (0, argv, 0) == 0)
return -1; /* out of memory */
if ((mypanel = LoadPanel (0, "display_histogram.uir", MYPANEL)) < 0)
return -1;
DisplayPanel (mypanel);
SourImage = imaqCreateImage (IMAQ_IMAGE_U8, 2);
RunUserInterface ();
DiscardPanel (mypanel);
return 0;
}
int main (int argc, char *argv[])
{
if (InitCVIRTE (0, argv, 0) == 0)
return -1; /* out of memory */
if ((mypanel = LoadPanel (0, "threshold_selection.uir", MYPANEL)) < 0)
return -1;
DisplayPanel (mypanel);
sourimage = imaqCreateImage (IMAQ_IMAGE_U8, 2);
destimage = imaqCreateImage (IMAQ_IMAGE_U8, 2);
RunUserInterface ();
DiscardPanel (mypanel);
return 0;
}
void dda08Operate (int menubar, int menuItem, void *callbackData, int panel)
{
MCCdevPtr dev = callbackData;
dda08Ptr dda = dev->device;
acqchanPtr acqchan;
int i, x = 0, m;
if(!dda->panel)
{
dda->panel = LoadPanel(utilG.p, "DDA08u.uir", DDA_CTRL);
SetCtrlAttribute (dda->panel, DDA_CTRL_RANGE_0, ATTR_CALLBACK_DATA, &dda->Achannels[0]->port.analogueIOport.range);
SetCtrlAttribute (dda->panel, DDA_CTRL_RANGE_1, ATTR_CALLBACK_DATA, &dda->Achannels[1]->port.analogueIOport.range);
SetCtrlAttribute (dda->panel, DDA_CTRL_RANGE_2, ATTR_CALLBACK_DATA, &dda->Achannels[2]->port.analogueIOport.range);
SetCtrlAttribute (dda->panel, DDA_CTRL_RANGE_3, ATTR_CALLBACK_DATA, &dda->Achannels[3]->port.analogueIOport.range);
SetCtrlAttribute (dda->panel, DDA_CTRL_RANGE_4, ATTR_CALLBACK_DATA, &dda->Achannels[4]->port.analogueIOport.range);
SetCtrlAttribute (dda->panel, DDA_CTRL_RANGE_5, ATTR_CALLBACK_DATA, &dda->Achannels[5]->port.analogueIOport.range);
SetCtrlAttribute (dda->panel, DDA_CTRL_RANGE_6, ATTR_CALLBACK_DATA, &dda->Achannels[6]->port.analogueIOport.range);
SetCtrlAttribute (dda->panel, DDA_CTRL_RANGE_7, ATTR_CALLBACK_DATA, &dda->Achannels[7]->port.analogueIOport.range);
SetCtrlAttribute (dda->panel, DDA_CTRL_ANALOG_OUT_0, ATTR_CALLBACK_DATA, dda->Achannels[0]->port.analogueIOport.IO.source);
SetCtrlAttribute (dda->panel, DDA_CTRL_ANALOG_OUT_1, ATTR_CALLBACK_DATA, dda->Achannels[1]->port.analogueIOport.IO.source);
SetCtrlAttribute (dda->panel, DDA_CTRL_ANALOG_OUT_2, ATTR_CALLBACK_DATA, dda->Achannels[2]->port.analogueIOport.IO.source);
SetCtrlAttribute (dda->panel, DDA_CTRL_ANALOG_OUT_3, ATTR_CALLBACK_DATA, dda->Achannels[3]->port.analogueIOport.IO.source);
SetCtrlAttribute (dda->panel, DDA_CTRL_ANALOG_OUT_4, ATTR_CALLBACK_DATA, dda->Achannels[4]->port.analogueIOport.IO.source);
SetCtrlAttribute (dda->panel, DDA_CTRL_ANALOG_OUT_5, ATTR_CALLBACK_DATA, dda->Achannels[5]->port.analogueIOport.IO.source);
SetCtrlAttribute (dda->panel, DDA_CTRL_ANALOG_OUT_6, ATTR_CALLBACK_DATA, dda->Achannels[6]->port.analogueIOport.IO.source);
SetCtrlAttribute (dda->panel, DDA_CTRL_ANALOG_OUT_7, ATTR_CALLBACK_DATA, dda->Achannels[7]->port.analogueIOport.IO.source);
SetCtrlAttribute (dda->panel, DDA_CTRL_SOURCE_0, ATTR_CALLBACK_DATA, dda->Achannels[0]->port.analogueIOport.IO.source);
SetCtrlAttribute (dda->panel, DDA_CTRL_SOURCE_1, ATTR_CALLBACK_DATA, dda->Achannels[1]->port.analogueIOport.IO.source);
SetCtrlAttribute (dda->panel, DDA_CTRL_SOURCE_2, ATTR_CALLBACK_DATA, dda->Achannels[2]->port.analogueIOport.IO.source);
SetCtrlAttribute (dda->panel, DDA_CTRL_SOURCE_3, ATTR_CALLBACK_DATA, dda->Achannels[3]->port.analogueIOport.IO.source);
SetCtrlAttribute (dda->panel, DDA_CTRL_SOURCE_4, ATTR_CALLBACK_DATA, dda->Achannels[4]->port.analogueIOport.IO.source);
SetCtrlAttribute (dda->panel, DDA_CTRL_SOURCE_5, ATTR_CALLBACK_DATA, dda->Achannels[5]->port.analogueIOport.IO.source);
SetCtrlAttribute (dda->panel, DDA_CTRL_SOURCE_6, ATTR_CALLBACK_DATA, dda->Achannels[6]->port.analogueIOport.IO.source);
SetCtrlAttribute (dda->panel, DDA_CTRL_SOURCE_7, ATTR_CALLBACK_DATA, dda->Achannels[7]->port.analogueIOport.IO.source);
SetCtrlAttribute (dda->panel, DDA_CTRL_OUT_ON_0, ATTR_CALLBACK_DATA, dda->buttons[0]);
SetCtrlAttribute (dda->panel, DDA_CTRL_OUT_ON_1, ATTR_CALLBACK_DATA, dda->buttons[1]);
SetCtrlAttribute (dda->panel, DDA_CTRL_OUT_ON_2, ATTR_CALLBACK_DATA, dda->buttons[2]);
SetCtrlAttribute (dda->panel, DDA_CTRL_OUT_ON_3, ATTR_CALLBACK_DATA, dda->buttons[3]);
SetCtrlAttribute (dda->panel, DDA_CTRL_OUT_ON_4, ATTR_CALLBACK_DATA, dda->buttons[4]);
SetCtrlAttribute (dda->panel, DDA_CTRL_OUT_ON_5, ATTR_CALLBACK_DATA, dda->buttons[5]);
SetCtrlAttribute (dda->panel, DDA_CTRL_OUT_ON_6, ATTR_CALLBACK_DATA, dda->buttons[6]);
SetCtrlAttribute (dda->panel, DDA_CTRL_OUT_ON_7, ATTR_CALLBACK_DATA, dda->buttons[7]);
}
DisplayPanel(dda->panel);
}
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");
}
//Main - displays the GUI
int main (int argc, char *argv[])
{
//Check for errors
if (InitCVIRTE (0, argv, 0) == 0)
return -1; /* out of memory */
if ((panelHandle = LoadPanel (0, "pictest.uir", PANEL)) < 0)
return -1;
//Run GUI
DisplayPanel (panelHandle);
RunUserInterface ();
DiscardPanel (panelHandle);
return 0;
}
int CVICALLBACK fit_options (int panel, int control, int event,
void *callbackData, int eventData1, int eventData2)
{
switch (event)
{
case EVENT_COMMIT:
if ((Fit_pnl_handle = LoadPanel (0, "Fit_Options.uir", Fit_panel)) < 0)
return -1;
DisplayPanel (Fit_pnl_handle );
RunUserInterface ();
DiscardPanel (Fit_pnl_handle );
break;
}
return 0;
}
/*---------------------------------------------------------------------------*/
int main (int argc, char *argv[])
{
if (InitCVIRTE (0, argv, 0) == 0)
return -1;
DisableBreakOnLibraryErrors ();
setup_oscillo();
setup_SRS();
generate_xarray ();
if ((Main_pnl_handle = LoadPanel (0, "ERG.uir", ERG_panel)) < 0)
return -1;
DisplayPanel (Main_pnl_handle);
RunUserInterface ();
DiscardPanel (Main_pnl_handle);
return 0;
}
void das1602_MenuCallback(int menbar, int menuItem, void *callbackData, int panel)
{
switch (menuItem)
{
case DASMENU_MEAS_IN_0:
case DASMENU_MEAS_IN_1:
case DASMENU_MEAS_IN_2:
case DASMENU_MEAS_IN_3:
case DASMENU_MEAS_IN_4:
case DASMENU_MEAS_IN_5:
case DASMENU_MEAS_IN_6:
case DASMENU_MEAS_IN_7:
if(utilG.acq.status != ACQ_BUSY){
portPtr port = callbackData;
MCCdevPtr dev = port->port.analogueIOport.IO.acqchan->dev;
das1602Ptr das = dev->device;
port->menuitem_id = menuItem;
port->measPanel = port->measPanel? port->measPanel : LoadPanel(utilG.p, "DAS-1602u.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 DASMENU_SOURCE_DAC1:
case DASMENU_SOURCE_DAC2:
{
sourcePtr src = callbackData;
switch(utilG.exp)
{
case EXP_SOURCE: source_InitPanel(src); break;
case EXP_FLOAT : gensrc_InitPanel(src); break;
}
}
break;
}
}
void usb1208lsOperate (int menubar, int menuItem, void *callbackData, int panel)
{
MCCdevPtr dev = callbackData;
usb1208lsPtr pmd = dev->device;
acqchanPtr acqchan;
int i, x = 0, m;
if(!pmd->panel)
{
pmd->panel = LoadPanel(utilG.p, "USB-1208LSu.uir", USB1208LS);
pmd->menu = LoadMenuBar(pmd->panel, "USB-1208LSu.uir", USBMENU);
SetPanelMenuBar(pmd->panel, pmd->menu);
for(i = 0; i < 4; i ++)
{
SetMenuBarAttribute (pmd->menu, pmd->aiPorts[i]->menuitem_id, ATTR_CALLBACK_DATA, pmd->aiPorts[i]);
SetMenuBarAttribute (pmd->menu, pmd->aiPorts[i]->menuitem_id, ATTR_ITEM_NAME, pmd->aiPorts[i]->port.analogueIOport.IO.acqchan->channel->label);
SetMenuBarAttribute (pmd->menu, pmd->aiPorts[i]->menuitem_id, ATTR_CHECKED, pmd->aiPorts[i]->port.analogueIOport.IO.acqchan->acquire);
}
SetMenuBarAttribute (pmd->menu, USBMENU_SOURCE_DAC1, ATTR_CALLBACK_DATA, pmd->aoPorts[0]->port.analogueIOport.IO.source);
SetMenuBarAttribute (pmd->menu, USBMENU_SOURCE_DAC2, ATTR_CALLBACK_DATA, pmd->aoPorts[1]->port.analogueIOport.IO.source);
SetMenuBarAttribute (pmd->menu, USBMENU_SOURCE_DAC3, ATTR_CALLBACK_DATA, pmd->aoPorts[2]->port.analogueIOport.IO.source);
SetMenuBarAttribute (pmd->menu, USBMENU_SOURCE_DAC4, ATTR_CALLBACK_DATA, pmd->doPort);
SetMenuBarAttribute (pmd->menu, USBMENU_SOURCE_DAC1, ATTR_ITEM_NAME, pmd->aoPorts[0]->port.analogueIOport.IO.source->acqchan->channel->label);
SetMenuBarAttribute (pmd->menu, USBMENU_SOURCE_DAC2, ATTR_ITEM_NAME, pmd->aoPorts[1]->port.analogueIOport.IO.source->acqchan->channel->label);
SetMenuBarAttribute (pmd->menu, USBMENU_SOURCE_DAC3, ATTR_ITEM_NAME, pmd->aoPorts[2]->port.analogueIOport.IO.source->acqchan->channel->label);
SetMenuBarAttribute (pmd->menu, USBMENU_FILE_SAVE, ATTR_CALLBACK_DATA, dev);
SetMenuBarAttribute (pmd->menu, USBMENU_FILE_LOAD, ATTR_CALLBACK_DATA, dev);
SetCtrlAttribute (pmd->panel, USB1208LS_RANGE, ATTR_DIMMED, 1);
SetCtrlAttribute (pmd->panel, USB1208LS_ACQ, ATTR_DIMMED, 1);
/*SetCtrlAttribute (pmd->panel, USB1208LS_DIGITAL_OUT_0, ATTR_CALLBACK_DATA, pmd->doPort);
SetCtrlAttribute (pmd->panel, USB1208LS_DIGITAL_OUT_1, ATTR_CALLBACK_DATA, pmd->doPort);
SetCtrlAttribute (pmd->panel, USB1208LS_DIGITAL_OUT_2, ATTR_CALLBACK_DATA, pmd->doPort);
SetCtrlAttribute (pmd->panel, USB1208LS_DIGITAL_OUT_3, ATTR_CALLBACK_DATA, pmd->doPort);
SetCtrlAttribute (pmd->panel, USB1208LS_DIGITAL_OUT_4, ATTR_CALLBACK_DATA, pmd->doPort);
SetCtrlAttribute (pmd->panel, USB1208LS_DIGITAL_OUT_5, ATTR_CALLBACK_DATA, pmd->doPort);*/
SetCtrlAttribute (pmd->panel, USB1208LS_INPUT, ATTR_CALLBACK_DATA, pmd->aiPorts[0]);
SetPanelAttribute (pmd->panel, ATTR_CALLBACK_DATA, pmd);
}
SetMenuBarAttribute(menubar, menuItem, ATTR_DIMMED, 1);
devPanel_Add (pmd->panel, dev, usb1208ls_UpdateReadings);
DisplayPanel(pmd->panel);
}
/** @brief This function gives the button functionality
@param panel the panel handle of the panel on which the button is used
@param control the control on which the event is generated
@param event the type of event generated (i.e. left-click causes EVENT_COMMIT)
@param *callbackData stores the data returned to the UI handled internally by LabWindows
@param eventData1 stores ancillary information such as the mouse x-position within the panel
@param eventData2 stores ancillary information such as the mouse y-position within the panel
@return 1 or 0 specifies whether or not the event should be swallowed. 0 is default-no and 1 is yes-swallow.
### EXTERNAL VARIABLES
- extern int @ref panelHandle - "OpenPET.c"
- extern int @ref panelHandle_timemode_mb - "OpenPET.c"
- extern int @ref panelHandle_timemode_duc - "OpenPET.c"
- extern int @ref panelHandle_timemode_db - "OpenPET.c"
- extern int @ref panelHandle_timemode - "OpenPET.c"
- extern Stack @ref panel_stack - "UI_Common.c"
- extern OpenPETTree @ref current_location - "UI_Common.c"
### ABNORMAL TERMINATION CONDITIONS, ERROR AND WARNING MESSAGES
Errors may be generated by CVI/LabWindows. The LabWindows documentation is available online
at <a href="linkURL"> http://zone.ni.com/reference/en-XX/help/370051V-01/ </a>.
### ALGORITHM
When the button is clicked, the current location is updated, the proper panel is displayed, and the
stack is updated.
### DEVELOPMENT HISTORY
Date | Author | Email Address | Ver. |Description Of Change
--------|-----------------|--------------------|------|---------------------
08/09/2013| George Netscher | [email protected] | 1.0 |conclusion of summer work
### Copyright (c) 2013 by LBNL. All Rights Reserved.
*/
int CVICALLBACK TimeModeDB (int panel, int control, int event,
void *callbackData, int eventData1, int eventData2)
{
switch (event)
{
case EVENT_COMMIT:
// switch on control for DB0...DB7
switch (control)
{
case TIMEMODEDB_BUTTON_0:
current_location.DB = 0;
break;
case TIMEMODEDB_BUTTON_1:
current_location.DB = 1;
break;
case TIMEMODEDB_BUTTON_2:
current_location.DB = 2;
break;
case TIMEMODEDB_BUTTON_3:
current_location.DB = 3;
break;
case TIMEMODEDB_BUTTON_4:
current_location.DB = 4;
break;
case TIMEMODEDB_BUTTON_5:
current_location.DB = 5;
break;
case TIMEMODEDB_BUTTON_6:
current_location.DB = 6;
break;
case TIMEMODEDB_BUTTON_7:
current_location.DB = 7;
break;
}
DisplayPanel (panelHandle_timemode);
StackPush(&panel_stack, panel);
HidePanel (panel);
break;
}
return 0;
}
