RB1-CNC Retrofit

# EMC controller parameters for UPC with threading and pendant

# General note: Comments can either be preceded with a # or ; - either is
# acceptable, although # is in keeping with most linux config files.


# General section -------------------------------------------------------------
[EMC]

# Version of this INI file
VERSION =               $Revision: 1.6 $

# Name of machine, for use with display, etc.
MACHINE =               LinuxCNC-UPC-Thread-Pendant

# Name of NML file to use, default is emc.nml
#NML_FILE =              emc.nml

# Debug level, 0 means no messages. See src/emc/nml_int/emcglb.h for others
 DEBUG =                 0x00000001
# DEBUG =               0x00000007
# DEBUG =               0x7FFFFFFF

# Sections for display options ------------------------------------------------
[DISPLAY]

# Name of display program, e.g., xemc
DISPLAY =             axis
#DISPLAY =             gmoccapy
# DISPLAY =               usrmot
# DISPLAY =    tkemc
# Cycle time, in seconds, that display will sleep between polls
CYCLE_TIME =            0.100

# Path to help file
HELP_FILE =             doc/help.txt

# Initial display setting for position, RELATIVE or MACHINE
POSITION_OFFSET =       RELATIVE

# Initial display setting for position, COMMANDED or ACTUAL
POSITION_FEEDBACK =     ACTUAL

# Highest value that will be allowed for feed override, 1.0 = 100%
MAX_FEED_OVERRIDE =     1.2

# Prefix to be used
PROGRAM_PREFIX = /home/jim/linuxcnc/nc_files

# Introductory graphic
INTRO_GRAPHIC = linuxcnc.gif
INTRO_TIME = 2

# Enable popup balloon help
BALLOON_HELP = 1

#spindle speed VCP
PYVCP = spindle.xml

# Task controller section -----------------------------------------------------
[TASK]

# Name of task controller program, e.g., bridgeporttask
TASK =                  milltask

# Cycle time, in seconds, that task controller will sleep between polls
CYCLE_TIME =            0.010

# Part program interpreter section --------------------------------------------
[RS274NGC]

# File containing interpreter variables
PARAMETER_FILE =        univpwm.var

# Motion control section ------------------------------------------------------
[EMCMOT]

EMCMOT =              motmod

# Key for real OS shared memory, e.g., for simulated motion
SHMEM_KEY =             111

# Timeout for comm to emcmot, in seconds
COMM_TIMEOUT =          1.0

# Interval between tries to emcmot, in seconds
COMM_WAIT =             0.010

# Base task period, in nanoseconds - this is the fastest thread in the machine
BASE_PERIOD =                1000000
# Servo task period, in nanoseconds - will be rounded to an integer multiple
#   of BASE_PERIOD
SERVO_PERIOD =               1000000
# Trajectory Planner task period, in nanoseconds - will be rounded to an
#   integer multiple of SERVO_PERIOD
TRAJ_PERIOD =                10000000

# Hardware Abstraction Layer section --------------------------------------------------
[HAL]

# The run script first uses halcmd to execute any HALFILE
# files, and then to execute any individual HALCMD commands.
#

# list of hal config files to run through halcmd
# files are executed in the order in which they appear
HALFILE =                    univpwm_load.hal
HALFILE =                    univpwm_servo.hal
HALFILE =                    univpwm_io.hal
HALFILE =                    univpwm_motion.hal
#HALFILE =                    pendant.hal
#POSTGUI_HALFILE =            spindle.hal

# list of halcmd commands to execute
# commands are executed in the order in which they appear
#HALCMD =                    save neta

# Trajectory planner section --------------------------------------------------
[TRAJ]

AXES =                  3
# COORDINATES =         X Y Z R P W
COORDINATES =           X Y Z
HOME =                  0 0 0
LINEAR_UNITS =          inch
ANGULAR_UNITS =         degree
CYCLE_TIME =            0.010
DEFAULT_VELOCITY =      0.15
MAX_VELOCITY =          1.20
DEFAULT_ACCELERATION =  5.0
MAX_ACCELERATION =      5.0
PROBE_INDEX =           0
PROBE_POLARITY =        1

# Axes sections ---------------------------------------------------------------

# Important note about OUTPUT_SCALE and PWM_OUTPUT_SCALE
# For this configuration, OUTPUT_SCALE is not used, because
# EMC always overwrites it on shutdown.  So PWM_OUTPUT_SCALE
# was added to hold the scaling.  Someday the OUTPUT_SCALE
# issue may be fixed, and PWM_OUTPUT_SCALE will go away.

# Scaling:  The PWM_OUTPUT_SCALE should be the speed 
# in UNITS/second  (inches/sec or mm/sec) that would be
# reached if the PWM duty cycle was 100%.  It depends on
# the power supply voltage, motor RPM/Volt factor, and 
# gearing/screw pitch.  For example:
#
# Power supply voltage 50V
# Motor RPM/V     1000RPM/24V
# Gearing:  2 motor revs per 1 screw rev
# Screw pitch: 0.2" per turn
# 
# Max motor speed = 50V * 1000RPM/24V = 2083 RPM
# Max screw speed = 2083RPM * 1(screw)/2(motor) = 1041RPM
# Max table speed = 1041RPM * 0.2"/turn = 208 in/min
# Max table speed = 208 in/min / 60 seconds = 3.47 inches/sec
#
# Since max speed is reached at 100% duty cycle, PWM_OUTPUT_SCALE
# should be 3.47

# First axis
[AXIS_0]

TYPE =                          LINEAR
UNITS =                         0.03937007874016
HOME =                          0.000
MAX_VELOCITY =                  1.20
MAX_ACCELERATION =              5.0
PID_MAX_VEL =              1.2
BACKLASH = 0.000
CYCLE_TIME =                    0.001000
INPUT_SCALE =                   -128000
OUTPUT_SCALE = -1
MIN_LIMIT =                     -12.0
MAX_LIMIT =                     0.1
FERROR = 0.1
MIN_FERROR = 1.0
HOME_OFFSET =                    0.0
HOME_SEARCH_VEL =                0.5
HOME_LATCH_VEL =                 0.1
HOME_USE_INDEX =                 YES
HOME_IGNORE_LIMITS =             NO
DEADBAND =                         2e-05
P =                              1000
I =                              2.5
D =                                1
BIAS =                             0
FF0 =                              0
FF1 =                              0.42
FF2 =                              0.0125


# Second axis
[AXIS_1]

TYPE =                          LINEAR
UNITS =                         0.03937007874016
HOME =                          0.000
MAX_VELOCITY =                  1.20
MAX_ACCELERATION =              3.0
PID_MAX_VEL =              1.2
BACKLASH = 0.000
CYCLE_TIME =                    0.001000
INPUT_SCALE =                   -128000
OUTPUT_SCALE = -1
MIN_LIMIT =                     -10.0
MAX_LIMIT =                     10.0
FERROR = 0.002
MIN_FERROR = 1.005
HOME_OFFSET =                    0.0
HOME_SEARCH_VEL =                0.5
HOME_LATCH_VEL =                 0.1
HOME_USE_INDEX =                 YES
HOME_IGNORE_LIMITS =             NO
DEADBAND =                         7e-06
P =                              3000
I =                              2.5
D =                                40
BIAS =                             0
FF0 =                              0
FF1 =                              0.6
FF2 =                              0.001

# Third axis
[AXIS_2]

TYPE =                          LINEAR
UNITS =                         0.03937007874016
HOME =                          0.0
MAX_VELOCITY =                  1.20
MAX_ACCELERATION =              3.0
PID_MAX_VEL =              1.2
BACKLASH = 0.000
CYCLE_TIME =                    0.001000
INPUT_SCALE =                   128000
OUTPUT_SCALE = 1
MIN_LIMIT =                     -10.0
MAX_LIMIT =                     10.0
FERROR = 0.002
MIN_FERROR = 0.005
HOME_OFFSET =                    0.0
HOME_SEARCH_VEL =                0.5
HOME_LATCH_VEL =                 0.1
HOME_USE_INDEX =                 YES
HOME_IGNORE_LIMITS =             NO
DEADBAND =                         0.000075
P =                              1500
I =                              10
D =                                1.5
BIAS =                             0
FF0 =                              0
FF1 =                              0.3
FF2 =                              0.007



# section for main IO controller parameters -----------------------------------
[EMCIO]

# Name of IO controller program, e.g., io
EMCIO =     io

# cycle time, in seconds
CYCLE_TIME =    0.100

# tool table file
TOOL_TABLE =    univpwm.tbl

# section for external NML server parameters ----------------------------------
[EMCSERVER]
# Uncomment the following line if you need to run a remote GUI.
# EMCSERVER =           emcsvr

# loads all HAL modules for Universal PWM controller with threading
# this version activates velocity estimation in the PPMC driver
#     with the timestamp=xx parameter in the loadrt line
#     this will only work with rev 4 UPC firmware and EMC2.4.6 or later

# kinematics
loadrt trivkins
# motion controller, get name and thread periods from ini file
loadrt [EMCMOT]EMCMOT base_period_nsec=[EMCMOT]BASE_PERIOD servo_period_nsec=[EMCMOT]SERVO_PERIOD traj_period_nsec=[EMCMOT]SERVO_PERIOD key=[EMCMOT]SHMEM_KEY

# next load the PID module, for four PID loops
loadrt pid num_chan=4

# install Universal PWM Controller driver
loadrt hal_ppmc port_addr="0x378" timestamp="0x00"

# load realtime portion of scope, just to have it handy
loadrt scope_rt

# make some signals for the scope for tuning.
loadrt ddt count=4
loadrt not count=1
loadrt estop_latch count=1
loadrt and2 count=1
loadrt or2 count=1
loadrt conv_s32_float count=1
loadrt mult2 count=2
loadrt lowpass count=1

# set up the realtime thread
# read inputs first
addf ppmc.0.read       servo-thread
# then run the motion controller
addf motion-command-handler servo-thread
addf and2.0            servo-thread
addf estop-latch.0     servo-thread
addf motion-controller servo-thread
addf not.0	       servo-thread
# then the PID loops
addf pid.0.do-pid-calcs servo-thread
addf pid.1.do-pid-calcs servo-thread
addf pid.2.do-pid-calcs servo-thread
addf pid.3.do-pid-calcs servo-thread
#  for spindle
addf or2.0              servo-thread
addf conv-s32-float.0   servo-thread
addf mult2.0            servo-thread
addf mult2.1            servo-thread
addf lowpass.0          servo-thread
# write outputs last
addf ppmc.0.write servo-thread

# HAL config file for servos -- expanded from core_servo.hal
# for a full four axis setup

# create four position feedback signals
newsig Xpos-fb float
newsig Ypos-fb float
newsig Zpos-fb float

# connect position feedback to PID loop
net Xpos-fb => pid.0.feedback
net Ypos-fb => pid.1.feedback
net Zpos-fb => pid.2.feedback

# connect position feedback to motion module
net Xpos-fb => axis.0.motor-pos-fb
net Ypos-fb => axis.1.motor-pos-fb
net Zpos-fb => axis.2.motor-pos-fb

# create PID to DAC output signals
newsig Xoutput float
newsig Youtput float
newsig Zoutput float

# connect output signals to output of PID loops
net Xoutput <= pid.0.output
net Youtput <= pid.1.output
net Zoutput <= pid.2.output
setp pid.0.maxoutput [AXIS_0]PID_MAX_VEL

# set PID loop output limits to +/-1.00
setp pid.1.maxoutput [AXIS_1]PID_MAX_VEL
setp pid.2.maxoutput [AXIS_2]PID_MAX_VEL

# set PID loop gains
setp pid.0.Pgain [AXIS_0]P
setp pid.0.Igain [AXIS_0]I
setp pid.0.Dgain [AXIS_0]D
setp pid.0.bias [AXIS_0]BIAS
setp pid.0.FF0 [AXIS_0]FF0
setp pid.0.FF1 [AXIS_0]FF1
setp pid.0.FF2 [AXIS_0]FF2
setp pid.0.deadband [AXIS_0]DEADBAND

setp pid.1.Pgain [AXIS_1]P
setp pid.1.Igain [AXIS_1]I
setp pid.1.Dgain [AXIS_1]D
setp pid.1.bias [AXIS_1]BIAS
setp pid.1.FF0 [AXIS_1]FF0
setp pid.1.FF1 [AXIS_1]FF1
setp pid.1.FF2 [AXIS_1]FF2
setp pid.1.deadband [AXIS_1]DEADBAND

setp pid.2.Pgain [AXIS_2]P
setp pid.2.Igain [AXIS_2]I
setp pid.2.Dgain [AXIS_2]D
setp pid.2.bias [AXIS_2]BIAS
setp pid.2.FF0 [AXIS_2]FF0
setp pid.2.FF1 [AXIS_2]FF1
setp pid.2.FF2 [AXIS_2]FF2
setp pid.2.deadband [AXIS_2]DEADBAND

# create four position command signals
newsig Xpos-cmd float
newsig Ypos-cmd float
newsig Zpos-cmd float

# connect position commands to motion controller
net Xpos-cmd <= axis.0.motor-pos-cmd
net Ypos-cmd <= axis.1.motor-pos-cmd
net Zpos-cmd <= axis.2.motor-pos-cmd

# connect position commands to PID input
net Xpos-cmd => pid.0.command
net Ypos-cmd => pid.1.command
net Zpos-cmd => pid.2.command

# create bit signals to enable/disable the PID loops
newsig Xenable bit
newsig Yenable bit
newsig Zenable bit

# connect the signals to the motion controller
net Xenable <= axis.0.amp-enable-out
net Yenable <= axis.1.amp-enable-out
net Zenable <= axis.2.amp-enable-out

# connect the signals to the PID blocks
net Xenable => pid.0.enable
net Yenable => pid.1.enable
net Zenable => pid.2.enable