Skip to content
Snippets Groups Projects
Commit 027b3514 authored by rivers's avatar rivers
Browse files

Deleted iocxxx directory, replaced with iocvxWorks

parent e9513738
No related branches found
No related tags found
No related merge requests found
Expand all Hide whitespace changes
Inline Side-by-side
iocBoot/iocxxx/st.cmd.solaris deleted 100644 → 0
+ 0
− 444
View file @ e9513738
dbLoadDatabase("dbPath.dbd")
dbLoadDatabase("../../dbd/xxxVx.dbd")
registerRecordDeviceDriver(pdbbase)
routerInit
localMessageRouterStart(1)
# Configure the MPF server code. This MUST be configured too!
< st_mpfserver.cmd.solaris
# Love Controllers
#devLoveDebug=1
#loveServerDebug=1
#dbLoadDatabase("ipApp/Db/love.db", ip, "P=xxx:,Q=Love_0,C=0,PORT=PORT2,ADDR=1");
# interpolation
#dbLoadDatabase("stdApp/Db/interp.db", std, "P=xxx:")
# 4-step measurement
#dbLoadDatabase("stdApp/Db/4step.db", std, "P=xxx:")
# X-ray Instrumentation Associates Huber Slit Controller
# supported by a customized version of the SNL program written by Pete Jemian
#dbLoadDatabase("stdApp/Db/xia_slit.db", std, "P=xxx:, HSC=hsc1:")
#dbLoadDatabase("stdApp/Db/xia_slit.db", std, "P=xxx:, HSC=hsc2:")
#dbLoadDatabase("ipApp/Db/generic_serial.db", ip, "P=xxx:,C=0,IPSLOT=a,CHAN=6,BAUD=9600,PRTY=None,DBIT=8,SBIT=1")
##### Pico Motors (Ernest Williams MHATT-CAT)
##### Motors (see picMot.substitutions in same directory as this file) ####
#!AuxdbLoadTemplate("picMot.substitutions", ip)
################################
# Sector 2 custom databases
################################
#M1 mirror stripe change database
#dbLoadDatabase("sectorApp/Db/stripe_change.db", top, "P=xxx:,M=m21")
#M2B 6 position select database
#bt dbLoadDatabase("sectorApp/Db/2motor_position_selector.db", top, "P=xxx:,D=M2B,M1=m29,M2=m30")
#M2C 6 position select database
#bt dbLoadDatabase("sectorApp/Db/2motor_position_selector.db", top, "P=xxx:,D=M2C,M1=m28,M2=m27")
################################
# End Sector 2 Custom databases
################################
##############################################################################
# Insertion-device control
dbLoadDatabase("stdApp/Db/IDctrl.db", std, "P=xxx:,xx=02us")
dbLoadDatabase("stdApp/Db/IDctrl.db", std, "P=xxx:,xx=02ds")
# test generic gpib record
#dbLoadDatabase("stdApp/Db/gpib.db", std, "P=xxx:")
# test generic camac record
#dbLoadDatabase("stdApp/Db/camac.db", std, "P=xxx:")
# string sequence (sseq) record
#dbLoadDatabase("stdApp/Db/yySseq.db", std, "P=xxx:,S=Sseq1")
#dbLoadDatabase("stdApp/Db/yySseq.db", std, "P=xxx:,S=Sseq2")
#dbLoadDatabase("stdApp/Db/yySseq.db", std, "P=xxx:,S=Sseq3")
###############################################################################
##### Motors (see motors.substitutions in same directory as this file) ####
#AuxdbLoadTemplate("basic_motor.substitutions", motor)
AuxdbLoadTemplate("motor.substitutions.rls", motor)
# OMS VME driver setup parameters:
# (1)cards, (2)axes per card, (3)base address(short, 16-byte boundary),
# (4)interrupt vector (0=disable or 64 - 255), (5)interrupt level (1 - 6),
# (6)motor task polling rate (min=1Hz,max=60Hz)
#omsSetup(2, 8, 0xFC00, 180, 5, 10)
# OMS VME58 driver setup parameters:
# (1)cards, (2)axes per card, (3)base address(short, 4k boundary),
# (4)interrupt vector (0=disable or 64 - 255), (5)interrupt level (1 - 6),
# (6)motor task polling rate (min=1Hz,max=60Hz)
#oms58Setup(3, 8, 0x3000, 190, 5, 10)
# Highland V544 driver setup parameters:
# (1)cards, (2)axes per card, (3)base address(short, 4k boundary),
# (4)interrupt vector (0=disable or 64 - 255), (5)interrupt level (1 - 6),
# (6)motor task polling rate (min=1Hz,max=60Hz)
#v544Setup(0, 4, 0xDD00, 0, 5, 10)
# Newport MM4000 driver setup parameters:
# (1) max. controllers, (2)Unused, (3)polling rate (min=1Hz,max=60Hz)
MM4000Setup(3, 0, 10)
# Newport MM4000 driver configuration parameters:
# (1)controller# being configured,
# (2)port type: 0-GPIB_PORT or 1-RS232_PORT,
# (3)GPIB link or MPF server location
# (4)GPIB address or hideos_task name
MM4000Config(0, 1, MPF_Server_Location, "a-Serial[0]")
# Newport PM500 driver setup parameters:
# (1) maximum number of controllers in system
# (2) maximum number of channels on any controller
# (3) motor task polling rate (min=1Hz,max=60Hz)
#PM500Setup(1, 3, 10)
# Newport PM500 configuration parameters:
# (1) card being configured
# (2) port type (0-GPIB_PORT, 1-RS232_PORT)
# (3) link for GPIB or hideos_card for RS-232
# (3)GPIB link or MPF server location
# (4) GPIB address (int) or mpf serial server name (string)
#PM500Config(0, 1, 1, "a-Serial[4]")
# A set of scan parameters for each positioner. This is a convenience
# for the user. It can contain an entry for each scannable thing in the
# crate.
AuxdbLoadTemplate("scanParms.substitutions", std)
###############################################################################
### Scalers: Joerger VSC8/16
dbLoadDatabase("stdApp/Db/Jscaler.db", std, "P=xxx:,S=scaler1,C=0")
# Joerger VSC setup parameters:
# (1)cards, (2)base address(ext, 256-byte boundary),
# (3)interrupt vector (0=disable or 64 - 255)
VSCSetup(1, 0xD0000000, 200)
### Allstop, alldone
# This database must agree with the motors and other positioners you've actually loaded.
# Several versions (e.g., all_com_32.db) are in stdApp/Db
dbLoadDatabase("stdApp/Db/all_com_32.db", std, "P=xxx:")
### Scan-support software
# crate-resident scan. This executes 1D, 2D, 3D, and 4D scans, and caches
# 1D data, but it doesn't store anything to disk. (See 'saveData' below for that.)
dbLoadDatabase("stdApp/Db/scan.db", std, "P=xxx:,MAXPTS1=2000,MAXPTS2=200,MAXPTS3=10,MAXPTS4=10,MAXPTSH=200")
# Slits
dbLoadDatabase("stdApp/Db/2slit.db", std, "P=xxx:,SLIT=Slit1V,mXp=m24,mXn=m26")
dbLoadDatabase("stdApp/Db/2slit.db", std, "P=xxx:,SLIT=Slit1H,mXp=m23,mXn=m25")
# under development...
#dbLoadDatabase("stdApp/Db/2slit_soft.db", std, "P=xxx:,SLIT=Slit2V,mXp=m13,mXn=m14")
#dbLoadDatabase("stdApp/Db/2slit_soft.db", std, "P=xxx:,SLIT=Slit2H,mXp=m15,mXn=m16")
# 2-post mirror
#dbLoadDatabase("stdApp/Db/2postMirror.db", std, "P=xxx:,Q=M1,mDn=m18,mUp=m17,LENGTH=0.3")
# User filters
#dbLoadDatabase("stdApp/Db/filterMotor.db", std, "P=xxx:,Q=fltr1:,MOTOR=m1,LOCK=fltr_1_2:")
#dbLoadDatabase("stdApp/Db/filterMotor.db", std, "P=xxx:,Q=fltr2:,MOTOR=m2,LOCK=fltr_1_2:")
#dbLoadDatabase("stdApp/Db/filterLock.db", std, "P=xxx:,Q=fltr2:,LOCK=fltr_1_2:,LOCK_PV=xxx:DAC1_1.VAL")
# Optical tables
#tableRecordDebug=1
# command line would be too long ( >128 chars). One way to shorten it...
cd std
dbLoadDatabase("stdApp/Db/table.db", 0, "P=xxx:,Q=Table1,T=table1,M0X=m31,M0Y=m12,M1Y=m13,M2X=m32,M2Y=m14,M2Z=m18,GEOM=SRI")
cd startup
### Monochromator support ###
# Kohzu and PSL monochromators: Bragg and theta/Y/Z motors
# standard geometry (geometry 1)
#dbLoadDatabase("stdApp/Db/kohzuSeq.db", std, "P=xxx:,M_THETA=m9,M_Y=m10,M_Z=m11,yOffLo=17.4999,yOffHi=17.5001")
# modified geometry (geometry 2)
#dbLoadDatabase("stdApp/Db/kohzuSeq.db", std, "P=xxx:,M_THETA=m9,M_Y=m10,M_Z=m11,yOffLo=4,yOffHi=36")
# Heidenhain ND261 encoder (for PSL monochromator)
#dbLoadDatabase("ipApp/Db/heidND261.db", ip, "P=xxx:,C=0,IPSLOT=a,CHAN=0")
# Heidenhain IK320 VME encoder interpolator
#dbLoadDatabase("stdApp/Db/IK320card.db", std, "P=xxx:,sw2=card0:,axis=1,switches=41344,irq=3")
#dbLoadDatabase("stdApp/Db/IK320card.db", std, "P=xxx:,sw2=card0:,axis=2,switches=41344,irq=3")
#dbLoadDatabase("stdApp/Db/IK320group.db" std, "P=xxx:,group=5")
#drvIK320RegErrStr()
# Spherical grating monochromator
#dbLoadDatabase("stdApp/Db/SGM.db", std, "P=xxx:,N=1,M_x=m7,M_rIn=m6,M_rOut=m8,M_g=m9")
# 4-bounce high-resolution monochromator
#dbLoadDatabase("stdApp/Db/hrSeq.db", std,"P=xxx:,N=1,M_PHI1=m9, M_PHI2=m10")
#dbLoadDatabase("stdApp/Db/hrSeq.db", std,"P=xxx:,N=2,M_PHI1=m11,M_PHI2=m12")
# dispersive-monochromator protection
#dbLoadDatabase("stdApp/Db/bprotect.db", std, "P=xxx:,M_BTHETA=m25,M_BTRANS=m26")
### Canberra AIM Multichannel Analyzer ###
#mcaRecordDebug=0
#devMcaMpfDebug=0
#mcaAIMServerDebug=0
#aimDebug=0
# AIMConfig(serverName, int etherAddr, int port, int maxChans,
# int maxSignals, int maxSequences, etherDev, queueSize)
#
# serverName: defined here, must agree with dbLoadDatabase command
# etherAddr: ethernet address of AIM module
# port: Which ADC port of the AIM module does this config involve? [1,2]
# maxChans: Histogram bins per signal per sequence. (If a multiplexor or
# MCS module is in use, this must agree with hardware setting.)
# maxSignals: How many signals (multiplexed ADC inputs)? (If a multiplexor
# or MCS module is in use, this must agree with hardware setting.)
# maxSequences: How many sequences (usually, a sequence is a "time slice")?
# etherDev: vxWorks device used to communicate over the network to AIM.
# Typically "ei0" for mv16x, mv17x; "dc0" for Motorola PowerPC
# queueSize: size of MPF message queue for this server (100 should be plenty)
#AIMConfig("AIM1/2", 0x674, 2, 2048, 1, 1, "ei0", 100)
#dbLoadDatabase("mcaApp/Db/mca.db", mca, "P=xxx:,M=mca1,INP=#C0 S0 @AIM1/2,DTYPE=MPF MCA,NCHAN=2048")
# Create ICB server for ADC, amplifier and HVPS
# picbServer = icbConfig(icbServer, maxModules, icbAddress, queueSize)
# This creates the ICB server and allocates configures the first module, module 0.
# Additional modules are added to this server with icbAddModule().
#picbServer = icbConfig("icb/1", 10, "NI674:3", 100)
# In the dbLoadDatabase commands CARD=(0,1) for (local/remote), SERVER=icbServer name from
# icbConfig, ADDR=module number from icbConfig() or icbAddModule().
#icbAddModule(picbServer, module, icbAddress)
# Note: ADDR is the module number, not the icb address. The correspondence between
# module number and icb address is made in icbConfig (for module number 0) or in
# icbAddModule.
#icbAddModule(picbServer, 1, "NI674:2")
#dbLoadDatabase("mcaApp/Db/icb_adc.db", mca, "P=xxx:,ADC=icbAdc1,CARD=0,SERVER=icb/1,ADDR=0")
#icbTcaConfig("icbTca/1", 1, "NI674:1", 100)
#dbLoadDatabase("mcaApp/Db/icb_tca.db", mca, "P=xxx:,TCA=icbTca1,MCA=mca1,CARD=0,SERVER=icb/1,ADDR=1")
#icbAddModule(picbServer, 2, "NI674:2")
#dbLoadDatabase("mcaApp/Db/icb_hvps.db",mca, "P=xxx:,HVPS=icbHvps1,CARD=0,SERVER=icb/1,ADDR=2")
#icbAddModule(picbServer, 3, "NI674:4")
#dbLoadDatabase("mcaApp/Db/icb_amp.db", mca, "P=xxx:,AMP=icbAmp1,CARD=0,SERVER=icb/1,ADDR=4")
# Load 13 element detector software
#< 13element.cmd
# Load 3 element detector software
#< 3element.cmd
### Struck 7201 multichannel scaler (same as SIS 3806 multichannel scaler)
#mcaRecordDebug = 10
#devSTR7201Debug = 10
#drvSTR7201Debug = 10
#dbLoadDatabase("mcaApp/Db/Struck8.db", mca, "P=xxx:mcs:")
#dbLoadDatabase("mcaApp/Db/simple_mca.db", mca, "P=xxx:mcs:,M=mca1,DTYP=Struck STR7201 MCS,PREC=3,INP=#C0 S0 @,CHANS=1000")
#dbLoadDatabase("mcaApp/Db/simple_mca.db", mca, "P=xxx:mcs:,M=mca2,DTYP=Struck STR7201 MCS,PREC=3,INP=#C0 S1 @,CHANS=1000")
#dbLoadDatabase("mcaApp/Db/simple_mca.db", mca, "P=xxx:mcs:,M=mca3,DTYP=Struck STR7201 MCS,PREC=3,INP=#C0 S2 @,CHANS=1000")
#dbLoadDatabase("mcaApp/Db/simple_mca.db", mca, "P=xxx:mcs:,M=mca4,DTYP=Struck STR7201 MCS,PREC=3,INP=#C0 S3 @,CHANS=1000")
#dbLoadDatabase("mcaApp/Db/simple_mca.db", mca, "P=xxx:mcs:,M=mca5,DTYP=Struck STR7201 MCS,PREC=3,INP=#C0 S4 @,CHANS=1000")
#dbLoadDatabase("mcaApp/Db/simple_mca.db", mca, "P=xxx:mcs:,M=mca6,DTYP=Struck STR7201 MCS,PREC=3,INP=#C0 S5 @,CHANS=1000")
#dbLoadDatabase("mcaApp/Db/simple_mca.db", mca, "P=xxx:mcs:,M=mca7,DTYP=Struck STR7201 MCS,PREC=3,INP=#C0 S6 @,CHANS=1000")
#dbLoadDatabase("mcaApp/Db/simple_mca.db", mca, "P=xxx:mcs:,M=mca8,DTYP=Struck STR7201 MCS,PREC=3,INP=#C0 S7 @,CHANS=1000")
# STR7201Setup(int numCards, int baseAddress, int interruptVector, int interruptLevel)
#STR7201Setup(2, 0xA0000000, 210, 6)
# STR7201Config(int card, int maxSignals, int maxChans, int 1=enable internal 25MHZ clock)
#STR7201Config(0, 8, 1000, 0)
### Acromag IP330 in sweep mode ###
#dbLoadDatabase("mcaApp/Db/mca.db", mca, "P=xxx:,M=mADC_1,DTYPE=ip330Sweep,NCHAN=2048,INP=#C0 S0 @d-Ip330Sweep")
### Stand-alone user calculations ###
dbLoadDatabase("stdApp/Db/userCalcs10.db", std, "P=xxx:")
dbLoadDatabase("stdApp/Db/userStringCalcs10.db", std, "P=xxx:")
dbLoadDatabase("stdApp/Db/userTransforms10.db", std, "P=xxx:")
# extra userCalcs (must also load userCalcs10.db for the enable switch)
dbLoadDatabase("stdApp/Db/userCalcN.db", std, "P=xxx:,N=I_Detector")
### serial support ###
# generic serial ports
#dbLoadDatabase("ipApp/Db/generic_serial.db", ip, "P=xxx:,C=0,IPSLOT=a,CHAN=0,BAUD=9600,PRTY=None,DBIT=8,SBIT=1")
# serial O/I block (generic serial record with format and parse string calcs)
# on epics/mpf processor
#dbLoadDatabase("ipApp/Db/serial_OI_block.db", ip, "P=xxx:,N=0_1,C=0,IPSLOT=a,CHAN=4")
# on stand-alone mpf processor
#dbLoadDatabase("ipApp/Db/serial_OI_block.db", ip, "P=xxx:,N=1_1,C=0,IPSLOT=a,CHAN=4")
# Stanford Research Systems SR570 Current Preamplifier
#dbLoadDatabase("ipApp/Db/SR570.db", ip, "P=xxx:,A=A1,C=0,IPSLOT=a,CHAN=0")
# Lakeshore DRC-93CA Temperature Controller
#dbLoadDatabase("ipApp/Db/LakeShoreDRC-93CA.db", ip, "P=xxx:,Q=TC1,C=0,IPSLOT=a,CHAN=3")
# Huber DMC9200 DC Motor Controller
#dbLoadDatabase("ipApp/Db/HuberDMC9200.db", ip, "P=xxx:,Q=DMC1:,C=0,IPSLOT=a,CHAN=5")
# Oriel 18011 Encoder Mike
#dbLoadDatabase("ipApp/Db/eMike.db", ip, "P=xxx:,M=em1,C=0,IPSLOT=a,CHAN=2")
# Keithley 2000 DMM
#dbLoadDatabase("ipApp/Db/Keithley2kDMM_mf.db", ip, "P=xxx:,Dmm=D1,C=0,IPSLOT=a,CHAN=0")
# Oxford Cyberstar X1000 Scintillation detector and pulse processing unit
#dbLoadDatabase("ipApp/Db/Oxford_X1k.db", ip, "P=xxx:,S=s1,C=0,IPSLOT=a,CHAN=3")
# Oxford ILM202 Cryogen Level Meter (Serial)
#dbLoadDatabase("ipApp/Db/Oxford_ILM202.db", ip, "P=xxx:,S=s1,C=0,IPSLOT=c,CHAN=2")
### GPIB support ###
# GPIB O/I block (generic gpib record with format and parse string calcs)
# See HiDEOSGpibLinkConfig() below.
#dbLoadDatabase("ipApp/Db/GPIB_OI_block.db", ip, "P=xxx:,N=1,L=10")
# Heidenhain AWE1024 at GPIB address $(A)
#dbLoadDatabase("ipApp/Db/HeidAWE1024.db", ip, "P=xxx:,L=10,A=6")
# Keithley 199 DMM at GPIB address $(A)
#dbLoadDatabase("stdApp/Db/KeithleyDMM.db", std, "P=xxx:,L=10,A=26")
### Miscellaneous ###
# Systran DAC database
#dbLoadDatabase("ipApp/Db/DAC.db", ip, "P=xxx:,D=1,C=1,N=1,S=0,IPSLOT=c")
#dbLoadDatabase("ipApp/Db/DAC.db", ip, "P=xxx:,D=1,C=1,N=2,S=1,IPSLOT=c")
#dbLoadDatabase("ipApp/Db/DAC.db", ip, "P=xxx:,D=1,C=1,N=3,S=2,IPSLOT=c")
#dbLoadDatabase("ipApp/Db/DAC.db", ip, "P=xxx:,D=1,C=1,N=4,S=3,IPSLOT=c")
#dbLoadDatabase("ipApp/Db/DAC.db", ip, "P=xxx:,D=1,C=1,N=5,S=4,IPSLOT=c")
#dbLoadDatabase("ipApp/Db/DAC.db", ip, "P=xxx:,D=1,C=1,N=6,S=5,IPSLOT=c")
#dbLoadDatabase("ipApp/Db/DAC.db", ip, "P=xxx:,D=1,C=1,N=7,S=6,IPSLOT=c")
#dbLoadDatabase("ipApp/Db/DAC.db", ip, "P=xxx:,D=1,C=1,N=8,S=7,IPSLOT=c")
# vme test record
#dbLoadDatabase("stdApp/Db/vme.db", std, "P=xxx:,Q=vme1")
# Hewlett-Packard 10895A Laser Axis (interferometer)
#dbLoadDatabase("stdApp/Db/HPLaserAxis.db", std, "P=xxx:,Q=HPLaser1, C=0")
# hardware configuration
# example: devHP10895LaserAxisConfig(ncards,a16base)
#devHPLaserAxisConfig(2,0x1000)
# Acromag general purpose Digital I/O
#dbLoadDatabase("stdApp/Db/Acromag_16IO.db", std, "P=xxx:, A=1")
# Acromag AVME9440 setup parameters:
# devAvem9440Config (ncards,a16base,intvecbase)
#devAvme9440Config(1,0x0400,0x78)
# Miscellaneous PV's, such as burtResult
dbLoadDatabase("stdApp/Db/misc.db", std, "P=xxx:")
dbLoadDatabase("stdApp/Db/VXstats.db", std, "P=xxx:")
# Elcomat autocollimator
#dbLoadDatabase("ipApp/Db/Elcomat.db", ip, "P=xxx:,C=0,IPSLOT=a,CHAN=7")
# Bunch-clock generator
#dbLoadDatabase("stdApp/Db/BunchClkGen.db", std, "P=xxx:")
#dbLoadDatabase("stdApp/Db/BunchClkGenA.db", std, "UNIT=xxx")
# hardware configuration
# example: BunchClkGenConfigure(intCard, unsigned long CardAddress)
#BunchClkGenConfigure(0, 0x8c00)
### Queensgate piezo driver
#dbLoadDatabase("stdApp/Db/pzt_3id.db", std, "P=xxx:")
#dbLoadDatabase("stdApp/Db/pzt.db" , std, "P=xxx:")
### GP307 Vacuum Controller
#dbLoadDatabase("stdApp/Db/gp307.db", std, "P=xxx:")
### Queensgate Nano2k piezo controller
#dbLoadDatabase("stdApp/Db/Nano2k.db", std, "P=xxx:,S=s1")
# Eurotherm temp controller
#dbLoadDatabase("ipApp/Db/Eurotherm.db", ip, "P=xxx:,C=0,IPSLOT=a,CHAN=6")
#devAoEurothermDebug=20
# Analog I/O (Acromag IP330 ADC)
#AuxdbLoadTemplate("ip330Scan.substitutions", ip330)
# Machine-status board (MRD 100)
#####################################################
# dev32VmeConfig(card,a32base,nreg,iVector,iLevel)
# card = card number
# a32base = base address of card
# nreg = number of A32 registers on this card
# iVector = interrupt vector (MRD100 Only !!)
# iLevel = interrupt level (MRD100 Only !!)
# For Example
# devA32VmeConfig(0, 0x80000000, 44, 0, 0)
#####################################################
# Configure the MSL MRD 100 module.....
#devA32VmeConfig(0, 0xa0000200, 30, 0xa0, 5)
# VVVVVVVVVVVVVVVVVVVVV This doesn't look right (tmm) VVVVVVVVVVVVVVVVVVVVVVVVVVV
#dbLoadDatabase("stdApp/Db/msl_mrd100.db", std, "C=0,S=01,ID1=00,ID2=00us")
### Bit Bus configuration
# BBConfig(Link, LinkType, BaseAddr, IrqVector, IrqLevel)
# Link: ?
# LinkType: 0:hosed; 1:xycom; 2:pep
#BBConfig(3,1,0x2400,0xac,5)
###############################################################################
# Set shell prompt (otherwise it is left at mv167 or mv162)
shellPromptSet "iocxxx> "
#reboot_restoreDebug=5
iocLogDisable=1
iocInit
### startup State Notation Language programs
#seq &kohzuCtl, "P=xxx:, M_THETA=m9, M_Y=m10, M_Z=m11, GEOM=1, logfile=kohzuCtl.log"
#seq &hrCtl, "P=xxx:, N=1, M_PHI1=m9, M_PHI2=m10, logfile=hrCtl1.log"
# Keithley 2000 series DMM
# channels: 10, 20, or 22; model: 2000 or 2700
#seq &Keithley2kDMM,("P=xxx:, Dmm=D1, channels=20, model=2000")
# Bunch clock generator
#seq &getFillPat, "unit=xxx"
# X-ray Instrumentation Associates Huber Slit Controller
# supported by a SNL program written by Pete Jemian and modified (tmm) for use with the
# sscan record
#seq &xia_slit, "name=hsc1, P=xxx:, HSC=hsc1:, S=xxx:seriala[6]"
### Start up the autosave task and tell it what to do.
# The task is actually named "save_restore".
# (See also, 'initHooks' above, which is the means by which the values that
# will be saved by the task we're starting here are going to be restored.
#
# save positions every five seconds
create_monitor_set("auto_positions.req",5)
# save other things every thirty seconds
create_monitor_set("auto_settings.req",30)
### Start the saveData task.
# saveData_MessagePolicy
# 0: wait forever for space in message queue, then send message
# 1: send message only if queue is not full
# 2: send message only if queue is not full and specified time has passed (SetCptWait()
# sets this time.)
# 3: if specified time has passed, wait for space in queue, then send message
# else: don't send message
#debug_saveData = 2
saveData_MessagePolicy = 2
saveData_SetCptWait(.1)
saveData_Init("saveData.req", "P=xxx:")
#saveData_PrintScanInfo("xxx:scan1")
iocBoot/iocxxx/st.cmd.vxWorks deleted 100644 → 0
+ 0
− 514
View file @ e9513738
This diff is collapsed.
iocBoot/iocxxx/st1.cmd deleted 100644 → 0
+ 0
− 22
View file @ e9513738
cd ""
< ../nfsCommands
< cdCommands.68K
< MPFconfig.cmd
cd appbin
ld < mpfLib
ld < ipLib
ld < mpfserialserverLib
# Uncomment, as needed.
#ld < mpfgpibserverLib
#ld < dac128VLib
cd startup
#start message router
routerInit
tcpMessageRouterServerStart(1, 9900, Remote_IP, 1500, 40)
< st_mpfserver.cmd
shellPromptSet "iocxxx1> "
iocBoot/iocxxx/st_mpfserver.cmd.solaris deleted 100644 → 0
+ 0
− 5
View file @ e9513738
# This configures the MPF server stuff
initTtyPort("port0","/dev/ttyb",9600,"N",1,8,"N",1000)
initSerialServer("serial0","port0",1000,2,"")
iocBoot/iocxxx/st_mpfserver.cmd.vxWorks deleted 100644 → 0
+ 0
− 159
View file @ e9513738
# This configures the MPF server stuff
# First carrier
# slot a: IP-Octal (serial RS-232)
# slot b: IpUnidig (digital I/O)
# slot c: Ip330 (A/D converter)
# slot d: Dac128V (D/A converter)
###############################################################################
# Initialize IP carrier
# ipacAddCarrier(ipac_carrier_t *pcarrier, char *cardParams)
# pcarrier - pointer to carrier driver structure
# cardParams - carrier-specific init parameters
# Select for MVME162 or MVME172 CPU board IP carrier.
#carrier1=ipacAddMVME162("A:l=3,3 m=0xe0000000,64;B:l=3,3 m=0xe0010000,64;C:l=3,3 m=0xe0020000,64;D:l=3,3 m=0xe0030000,64")
# Select for SBS VIPC616-01 version IP carrier.
carrier1=ipacAddVIPC616_01("0x3000,0xa0000000")
###############################################################################
# Initialize Octal UART stuff
tyGSOctalDrv 1
tyGSOctalModuleInit("GSIP_OCTAL232", 0x80, 0, 0)
# int tyGSMPFInit(char *server, int uart, int channel, int baud, char parity, int sbits,
# int dbits, char handshake, char *eomstr)
tyGSMPFInit("serial1", 0, 0, 9600,'N',2,8,'N',"") /* SRS570 */
tyGSMPFInit("serial2", 0, 1,19200,'E',1,8,'N',"") /* MKS */
tyGSMPFInit("serial3", 0, 2, 9600,'E',1,7,'N',"") /* Digitel */
tyGSMPFInit("serial4", 0, 3, 9600,'N',1,8,'N',"") /* MPC */
tyGSMPFInit("serial5", 0, 4, 9600,'E',1,7,'N',"") /* McClennan PM304 */
tyGSMPFInit("serial6", 0, 5,19200,'N',1,8,'N',"") /* Keithley 2000 */
tyGSMPFInit("serial7", 0, 6, 9600,'N',1,8,'N',"") /* Oxford ILM cryometer */
tyGSMPFInit("serial8", 0, 7,19200,'N',1,8,'N',"") /* Love controllers */
# Initialize Greenspring IP-Unidig
# initIpUnidig(char *serverName,
# int carrier,
# int slot,
# int queueSize,
# int msecPoll,
# int intVec,
# int risingMask,
# int fallingMask,
# int biMask,
# int maxClients)
# serverName = name to give this server
# carrier = IPAC carrier number (0, 1, etc.)
# slot = IPAC slot (0,1,2,3, etc.)
# queueSize = size of output queue for EPICS
# msecPoll = polling time for input bits in msec. Default=100.
# intVec = interrupt vector
# risingMask = mask of bits to generate interrupts on low to high (24 bits)
# fallingMask = mask of bits to generate interrupts on high to low (24 bits)
# biMask = mask of bits to generate callbacks to bi record support
# This can be a subset of (risingMask | fallingMask)
# maxClients = Maximum number of callback tasks which will attach to this
# IpUnidig server. This
# does not refer to the number of EPICS clients. A value of
# 10 should certainly be safe.
initIpUnidig("Unidig1", 0, 1, 20, 2000, 116, 1, 1, 0xffff, 10)
# Initialize Acromag IP-330 ADC
# initIp330(
# const char *moduleName, int carrier, int slot,
# const char *typeString, const char *rangeString,
# int firstChan, int lastChan,
# int maxClients, int intVec)
# moduleName = name to give this module
# carrier = IPAC carrier number (0, 1, etc.)
# slot = IPAC slot (0,1,2,3, etc.)
# typeString = "D" or "S" for differential or single-ended
# rangeString = "-5to5","-10to10","0to5", or "0to10"
# This value must match hardware setting selected
# firstChan = first channel to be digitized. This must be in the range:
# 0 to 31 (single-ended)
# 0 to 15 (differential)
# lastChan = last channel to be digitized
# maxClients = Maximum number of Ip330 tasks which will attach to this
# Ip330 module. For example Ip330Scan, Ip330Sweep, etc. This
# does not refer to the number of EPICS clients. A value of
# 10 should certainly be safe.
# intVec Interrupt vector
initIp330("Ip330_1",0,2,"D","-5to5",0,15,10,120)
# configIp330(
# const char *moduleName,
# int scanMode, const char *triggerString,
# int microSecondsPerScan, int secondsBetweenCalibrate)
# moduleName = name of module passed to initIp330 above
# scanMode = scan mode:
# 0 = disable
# 1 = uniformContinuous
# 2 = uniformSingle
# 3 = burstContinuous (normally recommended)
# 4 = burstSingle
# 5 = convertOnExternalTriggerOnly
# triggerString = "Input" or "Output". Selects the direction of the external
# trigger signal.
# microSecondsPerScan = repeat interval to digitize all channels
# The minimum theoretical time is 15 microseconds times the
# number of channels, but a practical limit is probably 100
# microseconds.
# secondsBetweenCalibrate = number of seconds between calibration cycles.
# If zero then there will be no periodic calibration, but
# one calibration will still be done at initialization.
configIp330("Ip330_1", 3,"Input",500,0)
# initIp330Scan(
# const char moduleName, const char *serverName, int firstChan, int lastChan,
# int queueSize)
# moduleName = module name passed to initIp330 above
# serverName = name to give this server. Must match the INP parm field in
# EPICS records
# firstChan = first channel to be used by Ip330Scan. This must be in the
# range firstChan to lastChan specified in initIp330
# lastChan = last channel to be used by Ip330Scan. This must be in the range
# firstChan to lastChan specified in initIp330
# queueSize = size of output queue for MPF. Make this the maximum number
# of ai records attached to this server.
initIp330Scan("Ip330_1","Ip330Scan1",0,15,100)
# initIp330Sweep(char *moduleName, char *serverName, int firstChan,
# int lastChan, int maxPoints, int queueSize)
# moduleName = module name passed to initIp330 above
# serverName = name to give this server
# firstChan = first channel to be used by Ip330Sweep. This must be in the
# range firstChan to lastChan specified in initIp330
# lastChan = last channel to be used by Ip330Sweep. This must be in the
# range firstChan to lastChan specified in initIp330
# maxPoints = maximum number of points in a sweep. The amount of memory
# allocated will be maxPoints*(lastChan-firstChan+1)*4 bytes
# queueSize = size of output queue for EPICS
initIp330Sweep("Ip330_1","Ip330Sweep1",0,3,2048,100)
# initIp330PID(const char *serverName,
# char *ip330Name, int ADCChannel, dacName, int DACChannel,
# int queueSize)
# serverName = name to give this server
# ip330Name = module name passed to initIp330 above
# ADCChannel = ADC channel to be used by Ip330PID as its readback source.
# This must be in the range firstChan to lastChan specified in
# initIp330
# dacName = server name passed to initDAC128V
# DACChannel = DAC channel to be used by Ip330PID as its control output. This
# must be in the range 0-7.
# queueSize = size of output queue for EPICS
initIp330PID("Ip330PID1", "Ip330_1", 0, "DAC1", 0, 20)
# Initialize Systran DAC
# initDAC128V(char *serverName, int carrier, int slot, int queueSize)
# serverName = name to give this server
# carrier = IPAC carrier number (0, 1, etc.)
# slot = IPAC slot (0,1,2,3, etc.)
# queueSize = size of output queue for EPICS
#
initDAC128V("DAC1", 0, 3, 20)
iocBoot/iocxxx/vxStats.substitutions deleted 100644 → 0
+ 0
− 69
View file @ e9513738
#
# Macro Descriptions
#
# stats.db:
#
# P = first part of PV names.
# HMM = HOPR field of Maximum Free Memory Block (unit is bytes)
# WMM = LOW field of Maximum Free Memory Block
# AMM = LOLO field of Maximum Free Memory Block
# HCP = HOPR field of CPU Load (unit is %)
# WCP = HIGH field of CPU Load
# ACP = HIHI field of CPU Load
# HCL = HOPR field of CA Client count
# WCL = HIGH field of CA Client count
# ACL = HIHI field of CA Client count
# HCX = HOPR field of CA Connection count
# WCX = HIGH field of CA Connection count
# HCX = HIHI field of CA Connection count
# HFD = HOPR field of Available File Descriptor count
# WFD = LOW field of Available File Descriptor count
# AFD = LOLO field of Available File Descriptor count
# WMB = LOW field of % Free MBufs
# AMB = LOLO field of % Free MBufs
#
# reboot.db:
#
# P = first part of PV names.
# T = time in seconds that reboot enable stays high after button push.
#
# ClusterLine.template:
#
# P = first part of PV names.
# PO = pool (0 = Data, 1 = System)
# SI = size index (first size is index 0)
# SC = SCAN field content
#
file "$(VXSTATS)/db/stats.template"
{
{P=xxx:,
HMM=50000000,WMM=500000,AMM=100000,
HCP=100,WCP=50,ACP=80,
HCL=200,WCL=100,ACL=175,
HCX=2000,WCX=1000,ACX=1750,
HFD=150,WFD=20,AFD=5,WMB=50,AMB=10}
}
file "$(VXSTATS)/db/reboot.template"
{
{P=xxx:,T=3}
}
file "$(VXSTATS)/db/ClusterLine.template"
{
{P=xxx:,PO=0,SI=0,SC="10 second"}
{P=xxx:,PO=0,SI=1,SC="10 second"}
{P=xxx:,PO=0,SI=2,SC="10 second"}
{P=xxx:,PO=0,SI=3,SC="10 second"}
{P=xxx:,PO=0,SI=4,SC="10 second"}
{P=xxx:,PO=0,SI=5,SC="10 second"}
{P=xxx:,PO=0,SI=6,SC="10 second"}
{P=xxx:,PO=0,SI=7,SC="10 second"}
{P=xxx:,PO=1,SI=0,SC="10 second"}
{P=xxx:,PO=1,SI=1,SC="10 second"}
{P=xxx:,PO=1,SI=2,SC="10 second"}
{P=xxx:,PO=1,SI=3,SC="10 second"}
{P=xxx:,PO=1,SI=4,SC="10 second"}
{P=xxx:,PO=1,SI=5,SC="10 second"}
{P=xxx:,PO=1,SI=6,SC="10 second"}
{P=xxx:,PO=1,SI=7,SC="10 second"}
}
0% or .
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment