自学教程：C++ Fmt函数代码示例

void das1602_Create (MCCdevPtr dev){    int i;    char name[50];    das1602Ptr das = malloc(sizeof(das1602Type));        dev->device = das;    das->panel = 0;    for(i = 0; i < 8; i++)    {        //portPtr create_Port(*dev, *name, type, direction, GetReading, channel, range)        Fmt (name, "PCI-DAS1602 analog in %i", i);        das->Achannels[i] = create_Port(dev, name, ANALOGUE, IN_PORT, ReadAnalogue, i, BIP10VOLTS);        das->Achannels[i]->control = 0;    }    for(i = 0; i < 2; i++)    {        //portPtr create_Port(*dev, *name, type, direction, GetReading, SetLevel, channel, range)        Fmt (name, "PCI-DAS1602 analog out %i", i);        das->Achannels[i+8] = create_Port(dev, name, ANALOGUE, OUT_PORT, ReadAnalogueOut, SetAnalogue, i, BIP10VOLTS);        das->Achannels[i+8]->port.analogueIOport.IO.source->max = 10;        das->Achannels[i+8]->port.analogueIOport.IO.source->min = -10;        das->Achannels[i+8]->port.analogueIOport.IO.source->ranges.temprange[0] = range_Create(10, -10, 0.000305);    }    das->Achannels[0]->menuitem_id = DASMENU_MEAS_IN_0;    das->Achannels[1]->menuitem_id = DASMENU_MEAS_IN_1;    das->Achannels[2]->menuitem_id = DASMENU_MEAS_IN_2;    das->Achannels[3]->menuitem_id = DASMENU_MEAS_IN_3;    das->Achannels[4]->menuitem_id = DASMENU_MEAS_IN_4;    das->Achannels[5]->menuitem_id = DASMENU_MEAS_IN_5;    das->Achannels[6]->menuitem_id = DASMENU_MEAS_IN_6;    das->Achannels[7]->menuitem_id = DASMENU_MEAS_IN_7;}

int  DataFileSaveAsCallback(int panel, int control, int event, void *callbackData, int eventData1, int eventData2){    char path[300], path1[300], path2[300], name[300];    int i, filestatus;  char *date, mon[10], day[10], yr[10];	    if (event == EVENT_COMMIT) {        Fmt (name, "%s<%s.%i", dataFile.name, dataFile.ext);        filestatus = FileSelectPopup (dataFile.dir, name, "",                                      "Save As [file extension must be a #!]:",                                      VAL_OK_BUTTON, 0, 0, 1, 1, path);        switch (filestatus) {            case VAL_EXISTING_FILE_SELECTED:                MessagePopup ("Save As Message", "Cannot select duplicate file paths");                break;            case VAL_NEW_FILE_SELECTED:                Fmt (path1, path);                while (Scan(path1, "%s>%s[xdt92]%s", path2) == 2)                    Fmt (path1, path2);                Scan (path2, "%s>%s[t46]", dataFile.name);                i = Scan (path2, "%s>%s[xdt46]%i[b2]", &dataFile.ext);                if (i != 2)                    MessagePopup ("File name error",                              "File extension must be a number..."                              "extension ignored");                Fmt (path1, path);                i = FindPattern (path1, 0, StringLength (path1), path2, 0, 0);                CopyString (dataFile.dir, 0, path1, 0, i-1);                  acquire_UpdateDataFileInfo();                break;        }    }    return 0;}

int  DoClipCallback(int panel, int control, int event, void *callbackData, int eventData1, int eventData2){    int i;    double min, max;    channelPtr chan, newchan;    if (event == EVENT_COMMIT)    {        GetCtrlVal (panel, CLIP_CHANNELS, &i);        GetCtrlVal (panel, CLIP_MIN, &min);        GetCtrlVal (panel, CLIP_MAX, &max);        chan = channellist_GetItem (i);        newchan = channel_Create();        if (newchan && channel_AllocMem (newchan, chan->pts) &&            (Clip (chan->readings, chan->pts, max, min, newchan->readings) == NoErr))        {            Fmt (newchan->label, "%s (clipped)", chan->label);            Fmt (newchan->note, "%s/n%s/nmin = %f[e2p3]/nmax = %f[e2p3]/n",                 chan->note, newchan->label, min, max);            channellist_AddChannel (newchan);            return 1;        }        MessagePopup ("Clip Channel Message", "Error clipping channel--function voided");        if (newchan)        {            if (newchan->readings) free (newchan->readings);            free (newchan);        }    }    return 0;}

static void k213_GetErrorStatus (gpibioPtr dev){    int error, s;    char e_msg[256], *s_msg, rsp[256];    gpibio_Out (dev, "E?");    gpibio_In (dev, rsp);    Scan (rsp, "%s>E%i", &error);    switch (error) {        case 1: MessagePopup ("Keithley 213 Message", "ERROR: Unrecognized command"); break;        case 2: MessagePopup ("Keithley 213 Message", "ERROR: Invalid command parameter"); break;        case 3: MessagePopup ("Keithley 213 Message", "ERROR: Command conflict"); break;        case 4: MessagePopup ("Keithley 213 Message", "ERROR: Calibration switch not closed"); break;        case 5:            gpibio_Out (dev, "S?");            gpibio_In (dev, rsp);            Scan (rsp, "%s>S%i", &s);            Fmt (e_msg, "ERROR: Non-volatile RAM error, system defaults or calibration may be lost.");            if (s) s_msg = "User programmed defaults are still valid";                else s_msg = "Factory defaults are in use, user programmed defaults were lost";            Fmt (e_msg, "%s[a]</n%s", s_msg);            MessagePopup ("Keithley 213 Message", e_msg);            break;    }}

int  DoDecimateCallback(int panel, int control, int event, void *callbackData, int eventData1, int eventData2){    int i, dfact, ave;    channelPtr chan, newchan;    if (event == EVENT_COMMIT)    {        GetCtrlVal (panel, DECIMATE_CHANNELS, &i);        GetCtrlVal (panel, DECIMATE_DFACT, &dfact);        GetCtrlVal (panel, DECIMATE_AVE, &ave);        chan = channellist_GetItem (i);        newchan = channel_Create();        if (newchan && channel_AllocMem (newchan, (int)(chan->pts/dfact)) &&            (Decimate (chan->readings, chan->pts, dfact, ave, newchan->readings) == NoErr))        {            Fmt (newchan->label, "%s (decimated)", chan->label);            Fmt (newchan->note, "%s/n%s/ndfact = %i/nave = %i/n",                 chan->note, newchan->label, dfact, ave);            channellist_AddChannel (newchan);            return 1;        }        MessagePopup ("Decimate Channel Message", "Error decimating channel--function voided");        if (newchan)        {            if (newchan->readings) free (newchan->readings);            free (newchan);        }    }    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 usb1208ls_Init(void){    MCCdevTypePtr devType = malloc(sizeof(MCCdevTypeItem));    MCCdevTypePtr devType_alt = malloc(sizeof(MCCdevTypeItem));    if(utilG.acq.status != ACQ_NONE)    {        util_ChangeInitMessage ("usb-usb1208...");        if(devType)        {            Fmt(devType->id, PMD1208LS_ID);            Fmt(devType->label, "usb-1208ls");            devType->CreateDevice   = usb1208ls_Create;            devType->RemoveDevice   = usb1208ls_Remove;            devType->OperateDevice  = usb1208lsOperate;            devType->UpdateReadings = usb1208ls_UpdateReadings;            devType->SaveDevice     = usb1208ls_Save;            devType->LoadDevice     = usb1208ls_Load;            boards_DevTypeList_AddDev(devType);        }        if(devType_alt)        {            Fmt(devType_alt->id, PMD1208LS_ID_ALT);            Fmt(devType_alt->label, "usb-1208ls");            devType_alt->CreateDevice   = devType->CreateDevice;            devType_alt->RemoveDevice   = devType->RemoveDevice;            devType_alt->OperateDevice  = devType->OperateDevice;            devType_alt->UpdateReadings = devType->UpdateReadings;            devType_alt->SaveDevice     = devType->SaveDevice;            devType_alt->LoadDevice     = devType->LoadDevice;            boards_DevTypeList_AddDev(devType_alt);        }    }}

void InverseCallback(int menubar, int menuItem, void *callbackData, int panel){    channelPtr chan, newchan;    int pt, err;    chan = channellist_GetSelection();    err = FALSE;    newchan = channel_Create();    if (newchan && channel_AllocMem (newchan, chan->pts))    {        for (pt = 0; pt < chan->pts; pt++)        {            if (chan->readings[pt] != 0.0)                newchan->readings[pt] = 1/chan->readings[pt];            else {err = TRUE; break;}        }        if (!err)        {            Fmt (newchan->label, "%s<1 / (%s)", chan->label);            Fmt (newchan->note, "%s/n%s/n", chan->note, newchan->label);            channellist_AddChannel (newchan);        }        else {free (newchan->readings); free (newchan); newchan = NULL;}    }    else err = TRUE;    if (err)    {        MessagePopup ("Inverse Function Message", "Channel readings include 0.0 - function voided");        if (newchan) free (newchan);    }}

/** * @brief Generate simple xml report header. */void DirCmpReport::GenerateXmlHeader(){	WriteString(_T("")); // @todo xml declaration	WriteString(_T("<WinMergeDiffReport version=/"1/">/n"));	WriteString(Fmt(_T("<left>%s</left>/n"), m_rootPaths.GetLeft().c_str()));	WriteString(Fmt(_T("<right>%s</right>/n"), m_rootPaths.GetRight().c_str()));	WriteString(Fmt(_T("<time>%s</time>/n"), GetCurrentTimeString().c_str()));	// Add column headers	const CString rowEl = _T("column_name");	WriteString(BeginEl(rowEl));	for (int currCol = 0; currCol < m_nColumns; currCol++)	{		TCHAR columnName[160]; // Assuming max col header will never be > 160		LVCOLUMN lvc;		lvc.mask = LVCF_TEXT;		lvc.pszText = &columnName[0];		lvc.cchTextMax = countof(columnName);				const CString colEl = m_colRegKeys[currCol];		if (m_pList->GetColumn(currCol, &lvc))		{			WriteString(BeginEl(colEl));			WriteString(lvc.pszText);			WriteString(EndEl(colEl));		}	}	WriteString(EndEl(rowEl) + _T("/n"));}

static void k2400_Load (gpibioPtr dev){    char cmd[256];    double r;    int i;    k2400Ptr smu;	sourcePtr src;    if (dev){		smu = dev->device;		src = smu->source;	}    else smu = k2400_Create (NULL);/*  if (dev) k2400_Out (dev, "N0X");*/    ScanFile (fileHandle.analysis, "%s>Sense   : %i%s[dw1]", &smu->sense);    if (dev) {Fmt (cmd, ":SYSTem:RSENse %i", smu->sense); k2400_Out (dev, cmd, 0);}    ScanFile (fileHandle.analysis, "%s>Source  : %i, %i%s[dw1]",              &smu->src.current, &smu->src.delay);    if (dev) {		if(smu->src.current)		{			k2400_Out(dev, ":SOURce:FUNCtion:MODE CURRent", .07); 			k2400_Out(dev, ":SENSe:FUNCtion /"VOLTage/"", .07); 		}		else		{			k2400_Out(dev, ":SOURce:FUNCtion:MODE VOLTage", .07); 			k2400_Out(dev, ":SENSe:FUNCtion /"CURRent/"", .07); 		}		smu->source->sourceOn = 0;        Fmt (cmd, ":SOURce:DELay:AUTO %i", smu->src.delay);        k2400_Out (dev, cmd, 0);    }    smu->src.rangeV = 0;	smu->src.rangeC = 0;/*AUTO*/    smu->source->min = -110.0;    smu->source->max = 110.0;	k2400_Out(dev,":OUTPut:STATe?",0);	k2400_In(dev,cmd);	Scan(cmd, "%i", &smu->source->sourceOn);    source_Load (dev, smu->source);    ScanFile (fileHandle.analysis, "%s>Measure : %f, %i, %i, %f/0",             &r, &smu->meas.range, &smu->meas.filter, &smu->meas.inttime);    if (dev) {		Fmt (cmd, "SENSe:CURRent:NPLCycles %f", smu->meas.inttime);		k2400_Out (dev, cmd, 0);		Fmt (cmd, "SENSe:AVERage:COUNt %i", smu->meas.filter);        k2400_Out (dev, cmd, 0);    }    acqchan_Load (dev, smu->measure);    if (!dev) k2400_Remove (smu);}

int  SR844ControlCallback(int panel, int control, int event, void *callbackData, int eventData1, int eventData2){    int i;    char cmd[256], rsp[256];    gpibioPtr dev;    sr844Ptr lia;    dev = callbackData;    switch (control) {        case SR844_CTRL_TC:            if (event == EVENT_COMMIT) {				GetCtrlVal (panel, control, &i);                Fmt (cmd, "OFLT%i", i);                sr844_CheckClear(dev);				gpibio_Out (dev, cmd);            }            break;        case SR844_CTRL_SENS:            if (event == EVENT_COMMIT) {                GetCtrlVal (panel, control, &i);				Fmt (cmd, "SENS%i", i);                sr844_CheckClear(dev);				gpibio_Out (dev, cmd);            }            break;        case SR844_CTRL_AUTOSENSE:            if (event == EVENT_COMMIT) {				lia = dev->device;                GetCtrlVal (panel, control, &lia->autosens);                sr844_CheckClear(dev);				if(lia->autosens)				{					GetCtrlVal (panel, SR844_CTRL_SENS, &i);                	Fmt (cmd, "SENS%i", i);					gpibio_Out (dev, cmd);				}            }            break;        case SR844_CTRL_FILTSLOPE:            if (event == EVENT_COMMIT) {                GetCtrlVal (panel, control, &i);                Fmt (cmd, "OFSL%i", i);                sr844_CheckClear(dev);				gpibio_Out (dev, cmd);            }            break;       case SR844_CTRL_1MO50O:			if(event == EVENT_COMMIT)			{				GetCtrlVal (panel, control, &i);				Fmt (cmd, "INPZ%i", i);				sr844_CheckClear(dev);				gpibio_Out (dev, cmd);			}			break;    }    return 0;}

static void chanfunc_CalcStatistics (channelPtr chan){    double mean, std_dev, variance, rms, moment, median, mode, min, max;    int err, order, min_i, max_i, intervals;    char newnote[256];    Fmt (chanfunc.note, "");    err = MaxMin1D (chan->readings, chan->pts, &max, &max_i, &min, &min_i);    SetInputMode (chanfunc.p, STATISTICS_MIN, !err);    SetCtrlVal (chanfunc.p, STATISTICS_MIN, min);    SetInputMode (chanfunc.p, STATISTICS_MAX, !err);    SetCtrlVal (chanfunc.p, STATISTICS_MAX, max);    if (err == NoErr)    {        Fmt (chanfunc.note, "%s<Min: %f[e2p5]/n", min);        Fmt (chanfunc.note, "%s[a]<Max: %f[e2p5]/n", max);    }    err = Mean (chan->readings, chan->pts, &mean);    SetInputMode (chanfunc.p, STATISTICS_MEAN, !err);    SetCtrlVal (chanfunc.p, STATISTICS_MEAN, mean);    if (err == NoErr) Fmt (chanfunc.note, "%s[a]<Mean: %f[e2p5]/n", mean);    err = StdDev (chan->readings, chan->pts, &mean, &std_dev);    SetInputMode (chanfunc.p, STATISTICS_STDDEV, !err);    SetCtrlVal (chanfunc.p, STATISTICS_STDDEV, std_dev);    if (err == NoErr) Fmt (chanfunc.note, "%s[a]<StdDev: %f[e2p5]/n", std_dev);    err = Variance (chan->readings, chan->pts, &mean, &variance);    SetInputMode (chanfunc.p, STATISTICS_VAR, !err);    SetCtrlVal (chanfunc.p, STATISTICS_VAR, variance);    if (err == NoErr) Fmt (chanfunc.note, "%s[a]<Variance: %f[e2p5]/n", variance);    err = RMS (chan->readings, chan->pts, &rms);    SetInputMode (chanfunc.p, STATISTICS_RMS, !err);    SetCtrlVal (chanfunc.p, STATISTICS_RMS, rms);    if (err == NoErr) Fmt (chanfunc.note, "%s[a]<RMS: %f[e2p5]/n", rms);    GetCtrlVal (chanfunc.p, STATISTICS_ORDER, &order);    err = Moment (chan->readings, chan->pts, order, &moment);    SetInputMode (chanfunc.p, STATISTICS_MOMENT, !err);    SetInputMode (chanfunc.p, STATISTICS_ORDER, !err);    SetCtrlVal (chanfunc.p, STATISTICS_MOMENT, moment);    if (err == NoErr) Fmt (chanfunc.note, "%s[a]<Moment: %f[e2p5] (order: %i)/n", moment, order);    err = Median (chan->readings, chan->pts, &median);    SetInputMode (chanfunc.p, STATISTICS_MEDIAN, !err);    SetCtrlVal (chanfunc.p, STATISTICS_MEDIAN, median);    if (err == NoErr) Fmt (chanfunc.note, "%s[a]<Median: %f[e2p5]/n", median);    GetCtrlVal (chanfunc.p, STATISTICS_INTERVAL, &intervals);    err = Mode (chan->readings, chan->pts, min, max, intervals, &mode);    SetInputMode (chanfunc.p, STATISTICS_INTERVAL, !err);    SetInputMode (chanfunc.p, STATISTICS_MODE, !err);    SetCtrlVal (chanfunc.p, STATISTICS_INTERVAL, intervals);    SetCtrlVal (chanfunc.p, STATISTICS_MODE, mode);    if (err == NoErr) Fmt (chanfunc.note, "%s[a]<Mode: %f[e2p5] (intervals: %i)/n", mode, intervals);}

int CVIFUNC mouth_Error (const char message[], dnaByte abortQ,						 dnaByte forceErrorQ){	int status,err;	long count;	char mouthMessage[80]={0};#if VERBOSE > 0	if (forceErrorQ) {		FmtOut ("%s/n", message);		Beep();		Breakpoint();		ScanIn ("%s", mouthMessage);		// Wait for enter to be pressed		if (abortQ) abort();		return -1;	}			status = ThreadIbsta ();	if (status & ERR) {						// ERR is defined in gpib.h		err=ThreadIberr();		count = ThreadIbcntl();		FmtOut ("%s/n", message);		FmtOut ("status %d  error %d count %d/n", status,err,count);		FmtOut ("Library error so Abort always requested./n");		FmtOut ("Reminder: Did you turn on the SRS? to GPIB ID #19?/n");		Beep();		Breakpoint();		ScanIn ("%s", mouthMessage);		// Wait for enter to be pressed		if (abortQ) abort();		return -1;	}		#else	if (forceErrorQ) {		Beep();		MessagePopup ("Mouth Error", message);		Breakpoint();		if (abortQ) abort();		return -1;	}	status = ThreadIbsta ();	if (status & ERR) {		err=ThreadIberr();		count = ThreadIbcntl();		Fmt (mouthMessage, "%s<%s/n", message);		Fmt (mouthMessage, "%s[a]<status %d  error %d count %d/n", status,err,count);		if (abortQ)			Fmt (mouthMessage, "%s[a]<Software Error and Abort has been requested./n");		Fmt (mouthMessage, "%s[a]<Reminder: Did you turn on the SRS? to GPIB ID #19?/n");		Beep();		MessagePopup ("Mouth Error", mouthMessage);		Breakpoint();//		if (abortQ) abort();		return -1;	}		#endif	return 0;    }

void acquire_DataFileMakePath (void){   	char name[300], ext[10];	Fmt (ext, "%s<%f[p3]", (double)dataFile.ext/1000);    CopyBytes (ext, 0, ext, 1, 5);	    Fmt(name, "%s<%s%s", dataFile.name, ext);    MakePathname(dataFile.dir, name, dataFile.path);}

static void k2400_SetLevel (sourcePtr src){    char cmd[256];		gpibioPtr dev = src->acqchan->dev;		if(k2400_GetMode(dev))   		Fmt(cmd, ":SOURce:CURRent:LEVel %f", src->biaslevel); /* trigger new source value */	else		Fmt(cmd, ":SOURce:VOLTage:LEVel %f", src->biaslevel);    k2400_Out (dev, cmd, .02);    util_Delay (src->segments[src->seg]->delay);}

void AbsoluteCallback(int menubar, int menuItem, void *callbackData, int panel){    channelPtr chan, newchan;    chan = channellist_GetSelection();    newchan = channel_Create();    if (newchan && channel_AllocMem (newchan, chan->pts))    {        Abs1D (chan->readings, chan->pts, newchan->readings);        Fmt (newchan->label, "abs(%s)", chan->label);        Fmt (newchan->note, "%s/n%s/n", chan->note, newchan->label);        channellist_AddChannel (newchan);    }}

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);}

void NegativeCallback(int menubar, int menuItem, void *callbackData, int panel){    channelPtr chan, newchan;    chan = channellist_GetSelection();    newchan = channel_Create();    if (newchan && channel_AllocMem (newchan, chan->pts) &&        (Neg1D (chan->readings, chan->pts, newchan->readings) == NoErr))    {        Fmt (newchan->label, "%s<- (%s)", chan->label);        Fmt (newchan->note, "%s/n%s/n", chan->note, newchan->label);        channellist_AddChannel (newchan);    }    else MessagePopup ("Negative Function Message", "Random error...try again");}

void ReverseChannelCallback(int menubar, int menuItem, void *callbackData, int panel){    channelPtr chan, newchan;    chan = channellist_GetSelection();    newchan = channel_Create();    if (newchan && channel_AllocMem (newchan, chan->pts))    {        Fmt (newchan->label, "%s (reversed)", chan->label);        Fmt (newchan->note, "%s/n%s/n", chan->note, newchan->label);        Reverse (chan->readings, chan->pts, newchan->readings);        channellist_AddChannel (newchan);    }}

static void k213_SetPortLevel (int port, gpibioPtr dev){    char cmd[256];    k213Ptr quadsrc = dev->device;    sourcePtr src = quadsrc->port[port-1].src;    Fmt (cmd, "%s<C0P%iA%i", port, quadsrc->port[port-1].autorange);    if (!quadsrc->port[port-1].autorange)        Fmt (cmd, "%s[a]<R%i", quadsrc->port[port-1].range);    if (quadsrc->port[port-1].range == 0) Fmt (cmd, "%s[a]<V0X");        else Fmt (cmd, "%s[a]<V%f[p5]X", src->biaslevel);    k213_Out (dev, cmd);}

void sr844_GetXYRTP(gpibioPtr dev){	double hi, lo;	int i = 0, sens, senso;	char str[256];	sr844Ptr lia;	sr844_channels chan;	lia = dev->device;	sr844_GetCharVal (dev, "SNAP?1,2,3,5", str);	Scan (str, "%s>%f,%f,%f,%f",		&lia->channels[X]->reading,		&lia->channels[Y]->reading,		&lia->channels[R]->reading,		&lia->channels[T]->reading);	sr844_CheckClear(dev);	lia->channels[P]->reading = sr844_GetDoubleVal (dev, "PHAS?");	for (chan = X; chan <= P; chan++) lia->channels[chan]->newreading = TRUE;	if(lia->autosens)	{		senso = lia->sens;        hi = sr844_Conv2Sensitivity (lia->sens);        lo = sr844_Conv2Sensitivity (lia->sens-1);		if (lia->channels[R]->reading > hi) lia->sens++;        else if (lia->channels[R]->reading < lo) lia->sens--;		if(lia->sens < 0) lia->sens = 0;		if(lia->sens >14) lia->sens = 14;		Fmt (str, "SENS%i", lia->sens);        if(senso != lia->sens)			gpibio_Out (dev, str);	}}

void NormalScaleCallback(int menubar, int menuItem, void *callbackData, int panel){    channelPtr chan, newchan;    double scale, offset;    chan = channellist_GetSelection();    newchan = channel_Create();    if (newchan && channel_AllocMem (newchan, chan->pts))    {        Scale1D (chan->readings, chan->pts, newchan->readings, &offset, &scale);        Fmt (newchan->label, "Scale(%s)", chan->label);        Fmt (newchan->note, "%s/n%s/noffset: %f[e2p3]/nscale factor: %f[e2p3]/n",             chan->note, newchan->label, offset, scale);        channellist_AddChannel (newchan);    }}

void dda08_Create (MCCdevPtr dev){	int i;	char name[50];	dda08Ptr dda = malloc(sizeof(dda08Type));		dev->device = dda;	dda->panel = 0;	for(i = 0; i < 8; i++)	{		//portPtr create_Port(*dev, *name, type, direction, GetReading, SetLevel, channel, range)		Fmt (name, "DDA08 analog out %i", i);		dda->Achannels[i] = create_Port(dev, name, ANALOGUE, OUT_PORT, ReadAnalogueOut, SetAnalogue, i, BIP10VOLTS);		dda->Achannels[i]->port.analogueIOport.IO.source->max = 10;		dda->Achannels[i]->port.analogueIOport.IO.source->min = -10;		dda->Achannels[i]->port.analogueIOport.IO.source->ranges.temprange[0] = range_Create(10, -10, 0.000305);	}	dda->range[0] = range_Create(10, -10, 0.000305);	dda->range[1] = range_Create(5, -5, 0.0001525);	dda->range[2] = range_Create(2.5, -2.5, 0.00007625);	dda->buttons[0] = onoff_Create(DDA_CTRL_RANGE_0, DDA_CTRL_ANALOG_OUT_0, DDA_CTRL_SOURCE_0);	dda->buttons[1] = onoff_Create(DDA_CTRL_RANGE_1, DDA_CTRL_ANALOG_OUT_1, DDA_CTRL_SOURCE_1);	dda->buttons[2] = onoff_Create(DDA_CTRL_RANGE_2, DDA_CTRL_ANALOG_OUT_2, DDA_CTRL_SOURCE_2);	dda->buttons[3] = onoff_Create(DDA_CTRL_RANGE_3, DDA_CTRL_ANALOG_OUT_3, DDA_CTRL_SOURCE_3);	dda->buttons[4] = onoff_Create(DDA_CTRL_RANGE_4, DDA_CTRL_ANALOG_OUT_4, DDA_CTRL_SOURCE_4);	dda->buttons[5] = onoff_Create(DDA_CTRL_RANGE_5, DDA_CTRL_ANALOG_OUT_5, DDA_CTRL_SOURCE_5);	dda->buttons[6] = onoff_Create(DDA_CTRL_RANGE_6, DDA_CTRL_ANALOG_OUT_6, DDA_CTRL_SOURCE_6);	dda->buttons[7] = onoff_Create(DDA_CTRL_RANGE_7, DDA_CTRL_ANALOG_OUT_7, DDA_CTRL_SOURCE_7);}

int CVIFUNC mouth_AddBufferCommand (dnaBufferRF*buffer, double amp, double freq)// Takes frequency in MHz, Ampl Vpp{	int err=0;	if (freq!=LastFreq)		if (amp!=LastAmp) {			LastAmp=amp;			LastFreq=freq;			freq*=1000000.0;			// Convert to Hz			Fmt(&buffer->Buffer[buffer->PosByte],"%s<AMPL %fVP;FREQ %f",amp,freq);#if VERBOSE > 1			printf("%s/n",&buffer->Buffer[buffer->PosByte]);#endif			// Order of the next two commands is important 			buffer->NumberOfCommands++;			errChk(dna_AdvanceBufferRF (buffer));		}		else			errChk(mouth_AddBufferFreq(buffer,freq));	else		if (amp!=LastAmp)			errChk(mouth_AddBufferAmp(buffer,amp));		else {			buffer->Buffer[buffer->PosByte]=0;			// Order of the next two commands is important 			buffer->NumberOfCommands++;			errChk(dna_AdvanceBufferRF (buffer));		}			Error:	return (err?-1:0);}

int util_OpenFile(char *path, int action, int ascii){    int handle;    unsigned int  nBytes, pos, width;    long size;    char info[256];    if (action == FILE_WRITE) {        handle = OpenFile (path, FILE_WRITE, 0, ascii);        if (!ascii) FmtFile (handle, "BINARY/n");    }    else {        handle = OpenFile (path, action, 0, 0);        nBytes = ReadLine (handle, info, 255);        if (CompareBytes (info, 0, "BINARY", 0, 6, 0) != 0) {            CloseFile (handle);            handle = OpenFile (path, action, 0, 1);            ascii = TRUE;        }    }	if(handle)    {		fileP = LoadPanel (0, "utilu.uir", FILESTAT);    	    	if (action == FILE_WRITE) {        	Fmt (info, "Saving file: %s", path);        	if (ascii) Fmt (info, "%s[a]< (ASCII file...go for coffee!)");    	} else {        	GetFileSize (path, &size);        	Fmt (info, "Loading file: %s (%i kB)", path, size/1000);        	if (ascii) Fmt (info, "%s[a]< (ASCII file...take a nap!)");    	}    	SetCtrlVal (fileP, FILESTAT_TEXT, info);    	GetCtrlAttribute (fileP, FILESTAT_TEXT, ATTR_WIDTH, &width);    	SetPanelAttribute (fileP, ATTR_WIDTH, width+12);    	SetCtrlAttribute (fileP, FILESTAT_TEXT, ATTR_LEFT, 6);    	SetPanelPos (fileP, VAL_AUTO_CENTER, VAL_AUTO_CENTER);    	InstallPopup (fileP);	}	else		handle = 0;	return handle;}

/*----------------------------------------------------------------------------------------------------------------------------------------------------------.	Función: 	 GRA_IntStr. 	Descripcion: Convierte un valor entero a cadena y retorna el string.	Argumentos:	 int iValor | Valor a convertir a cadena.   Retorno:	 Apuntador tipo string----------------------------------------------------------------------------------------------------------------------------------------------------------*/char *GRA_IntStr(int iValor){	static char	cCadena[260]={0};	Fmt(cCadena,"%s<%d",iValor);	return cCadena;}

char *ENT_NeutralActual(){	static char cNeutral[20]={0};		Fmt(cNeutral,"%s<%s",cNeutralActual);		return cNeutral;}

void sr844_SetFREQ (sourcePtr src){	gpibioPtr dev = src->acqchan->dev;    char cmd[256];    double dly;    Fmt (cmd, "FREQ%f", src->biaslevel);    gpibio_Out (dev, cmd);    util_Delay (src->segments[src->seg]->delay);}

void sr844_SetDAC (gpibioPtr dev, int i, sourcePtr src){    char cmd[256];    double dly;    Fmt (cmd, "AUXO%i,%f", i, src->biaslevel);    gpibio_Out (dev, cmd);    util_Delay (src->segments[src->seg]->delay);}

void sr844_GetDAC (gpibioPtr dev, int i, sourcePtr src){    char cmd[256], rsp[256];    Fmt (cmd, "AUXO?%i", i);    sr844_GetCharVal(dev, cmd, rsp);    Scan (rsp, "%s>%f", &src->acqchan->reading);    src->acqchan->newreading = TRUE;}