Servida Designers and Manufacturers of Decentralized Drive Systems

This text is part of the Servida Motor BOOK. This manual, as well as the software described in it, is furnished under license and may be used or copied only in accordance with the terms of such license.The content of this manual is furnished for informational purposes only, is subject to change without notice, and should not be construed as a commitment by Servida. Servida assumes no responsibility or liability for any errors or inaccuracies that may appear in this book.
Except as permitted by such license, no part of this publication may be reproduced, stored in a retrieval system, or transmitted, in any form or by any means, electronic, mechanical, recording, or otherwise, without the prior written permission of Servida.

Enter the four commands below in the “Servida Motor Terminal” window, following each command with a return, and you will see motion:

Commands	Comments
A=100	‘Set Acceleration
V=1000000	‘Set Velocity
P=1000000	‘Set Position
G	‘Start move

On power-up the motor defaults to position mode. Once Acceleration (A) and Velocity (V) are set, you can simply issue new Position (P) commands, followed by a Go (G) command to execute moves to new absolute locations. The motor doesn't instantly go to the programmed position, but follows a trajectory to get there. The trajectory is bound by the maximum Velocity and Acceleration commands. This results in a trapezoidal velocity profile, or a triangular profile if the maximum velocity is never met.

You can change Position, Velocity and Acceleration at any time during or between moves. The new parameters will only apply when a new G command is sent.

Command Set

Commands are grouped by function - with the following notations:

#	Integer number
exp	Expression or signed integer
var	Variable
com	Communication channel

A=exp Set absolute acceleration

Acceleration must be a positive integer within the range of 0 to 2,147,483,648. The default is zero forcing you to enter something to get motion. A typical value is 100. If left unchanged, while the motor is working, this value will not only determine acceleration but also deceleration which will form a triangular or trapezoidal velocity motion profile. This value can be changed at any time. The value set doesn't get acted upon until the next G command is sent.

If your motor has a 2000 count encoder (sizes 17 & 23), multiply your desired acceleration in rev/sec2 by 7.91 to arrive at the number to set A to. With a 4000 count encoder (sizes 34, 42 & 56) you will need to multiply by 15.82. These constants are a function of the motors PID rate. If you lower the PID rate, you must raise these constants proportionally. See “The P.I.D. Filter” section of this manual for more information.

V=exp Set maximum permitted velocity

Use the V command to set a limit to what velocity the motor can accelerate to. That limit becomes the slew rate for all trajectory based motion whether in position mode or velocity mode. The value defaults to zero so it must be set before any motion can take place. The new value set does not take effect until the next G command is executed. If your motor has a 2000 count encoder (sizes 17 & 23), multiply your desired velocity in rev/sec by 32212 to arrive at the number to set V to. With a 4000 count encoder (sizes 34, 42 & 56) you will need to multiply by 64424. These constants are a function of the motors PID rate. If you lower the PID rate, you will need to raise these constants..

P=exp Set absolute position for move

The P= command allows the setting of an absolute end position. The number following is encoder counts and can be positive or negative. The end position can be set or changed at any time during or at the end of previous motions.

The following program illustrates how variables can be used to set motion values to real-world units and have the working values scaled for motor units.

a=100	‘Acceleration in rev/sec*sec
v=1	‘Velocity in rev/sec
p=100	‘Position in revs
GOSUB10	‘Initiate motion
END	‘End program
C10	‘Motion routine
A=a*8	‘Set Acceleration
V=v*32212	‘Set Velocity
P=p*2000	‘Set Position
G	‘Start move
RETURN	‘Return to call

D=exp Set relative distance for position move

The D= command will allow you to specify a relative distance, instead of an absolute position. The number following is encoder counts and can be positive or negative.

The relative distance will be added to the current position, either during or after a move. It is added to the desired position rather than the actual position so as to avoid the accumulation of small errors due to the fact that any servo motor is seldom exactly where it should be

G Go, start motion

The G command does more than just start motion. It can be used dynamically during motion to create elaborate profiles. Since the Servida Motor allows you to change Position, Velocity and Acceleration during motion, “on-the-fly”, the G command can be used to trigger the next profile at any time.

S Abruptly stop motion in progress

If the S command is issued while a move is in progress it will cause an immediate and abrupt stop with all the force the motor has to offer. After the stop, assuming there is no position error, the motor will still be servoing.

X Decelerate to stop

If the X command is issued while a move is in progress it will cause the motor to decelerate to a stop at the last entered A= value. When the motor comes to rest it will servo in place until commanded to move again.

O=exp Set/Reset origin to any position

The O= command (using the letter O, not the number zero) allows the host or program not just to declare the current position zero, but to declare it to be any position, positive or negative. The exact position to be re-declared is the ideal position, not the actual position which may be changing slightly due to hunting or variable loading.

OFF Turn motor servo off

The OFF command will stop the motor from servoing, much as a position error or limit fault would.

MP Position Mode

Position mode is the default mode of operation for the Servida Motor. If the mode were to be changed, however, the MP command would put it back into position mode. In position mode, the P# and D# commands will govern motion.

Binary Data Transfer

The ASCII based command string format, while convenient, is not the fastest way to communicate data. It can be burdensome when performing multi-axis contouring. For that reason a special binary format has been established for the communication of trajectory critical data such as Position, Velocity and Acceleration. These 32 bit parameters are sent as four bytes following a code byte that flags the data for a particular purpose. The code bytes are 252 for acceleration, 253 for velocity and 254 for position. As an example, the following byte values communicate A=52, V=-1 & P=2137483648.

A=52 252 000 000 000 052 032

V=-1 253 255 255 255 254 032

P=2137483648 254 127 255 255 255 032

For further expediency, the commands can be appended with the G command to start motion immediately. Two examples are as follows (the ASCII value for G is 71):

P=0 G 254 000 000 000 000 071 032

V=512 G 253 000 000 002 000 071 032

MV Velocity Mode

Velocity mode will allow continuous rotation of the motor shaft. In Velocity mode the programmed position using the P or the D commands is ignored. acceleration and velocity need to be specified using the A= and the V= commands. After a G command is issued, the motor will accelerate up to the programmed velocity and continue at that velocity indefinitely. In velocity mode as in Position mode, Velocity and Acceleration are changeable on-the-fly, at any time. Simply specify new values and enter another G command to trigger the change. In Velocity mode the velocity can be entered as a negative number, unlike in Position mode where the location of the target position determines velocity direction or sign. If the 32 bit register that holds position rolls over in velocity mode it will have no effect on the motion.

MT Torque Mode

In torque mode the motor shaft will simply apply a torque independent of position. The internal encoder tracking will still take place, and can be read by a host or program, but the value will be ignored for motion because the PID loop is inactive. To specify the amount of torque, use the T= command, followed by a number between -1023 and 1023.

T=exp Set torque value, -1023 to 1023

In torque mode, activated by the MT command, the actual torque value can be set with the T= command. The following number or variable must fall in the range between -1023 and 1023. The full scale value relates to full scale or maximum torque.

Brake commands
(where optional brake exists)

BRKRLS Brake release

BRKENG Brake engage

BRKSRV Release brake when servo active, engage break when inactive.

BRKTRJ Release brake when running a trajectory.

Engage under all other conditions.

Turns servo off when the brake is engaged.

Many Servida Motors are available with power safe brakes. These brakes will apply a force to keep the shaft from rotating should the unit lose power. Issuing the BRKRLS command will release the brake and BRKENG will engage it. There are two other commands that initiate automated operating modes for the brake. The command BRKSRV engages the brake automatically, should the motor stop servoing and holding position for any reason. This might be due to loss of power, a position error, limit fault, over-temperature fault, etc..

Finally, the BRKTRJ command will engage the brake in all of the previously mentioned circumstances, plus any time the motor is not performing a trajectory. In this mode the motor will be off, and the brake will be holding it in position, perfectly still, rather than the motor servoing when it is at rest,. As soon as another trajectory is started, the brake will release. The time it takes for the brake to engage and release is on the order of only a few milliseconds.

The brakes used in Servida Motors are zero-backlash devices with extremely long life spans. It is well within their capabilities to operate interactively within an application. You need to be careful not to create a situation where the brake will be set repeatedly during motion. That will reduce the brake's life.

2. Program Flow

Program commands are like chores, whether it is to turn on an output, set a velocity, start a move or whatever. A program is a list of these chores. When a programmed Servida Motor is powered-up or its program is reset with the Z command, it will execute its program in order from the beginning to the end.

RUN Execute stored user program

If you reset your program with a Z command you will erase all previous variables and mode changes for a fresh start. Alternatively you can use the RUN command to start the program in which case the state of the motor is unchanged and your program will be invoked.

RUN? Halt program if no RUN issued

To keep your downloaded program from executing at power-up start your program with the RUN? command. It will prevent the program from starting when power is applied, but it will not prevent the program from running when the Servida Motor sees a RUN command from a host over the RS-232 input.

Once your program is running, there are a variety of commands that can redirect program flow and most of those can do so based on certain conditions. How you set up these conditional decisions determines what your programmed Servida Motor will do, and exactly how “Servida ” it will actually be.

GOTO# Redirect program flow

C# Subroutine label, C0-C999

The most basic commands for redirecting program flow, without inherent conditions, are GOTO# in conjunction with C#. Labels are the letter C followed by a number (#) between 0 and 999 and are inserted in the program almost as place markers. If a label, C1 for this example, is placed in your program and you put that same number at the end of a GOTO command, GOTO1, the program flow will be redirected to label C1 and the program will proceed from there.

You can use as many as a thousand labels in your program (0 - 999), but, the more GOTO commands you use, the harder your code will be to debug or read. Try using only one and use it to create the infinite loop necessary to keep your program running indefinitely, as some embedded programs do. Put a C1 label at the beginning of your program and a GOTO1 at the end and every time the GOTO1 is reached the program will loop back to label C1 and start over from that point until the GOTO1 is reached again which will start the process all over at C1 and so on. You can write any program with only one GOTO. It might be a little harder, but it will tend to force you to better organize your program, which in turn will make it easier for others to read and for anyone to change.

END End program execution

If you want your program to stop, simply send an END command and execution will stop at that point. An END command can also be sent by the host to intervene and stop a program running within the motor. The program in your Servida Motor is never erased until you download a new one. If you want to erase the program on your motor download only the END command as if it were a new program and that's the only command that will be left on your Servida Motor until you download a new program.

GOSUB# Execute a subroutine

RETURN Return from subroutine

Just like the GOTO# command, the GOSUB# command, in conjunction with a C# label, will also redirect program execution in the same way. But, unlike the GOTO# command, the C# label needs a RETURN command at the end of the subroutine which will return the program to the location of the GOSUB# command that initiated the command. As an example; you want your Servida Motor to perform the same routine periodically throughout your program. For this we'll use GOSUB5 as an example which will send your program to the C5 label's subroutine. The subroutine will execute until the RETURN is reached which will send your program back to the GOSUB5 point where the diversion occurred and your program will continue on from there running the commands after the GOSUB5. If another GOSUB5 command is reached your program will return to the same subroutine at the C5 label and run the subroutine. But, now when it reaches the RETURN command it will return to the latest GOSUB5 command that sent it to the C5 label and forge on from there. The GOSUB5 command can be invoked as many times as you need throughout your program and will always return to the GOSUB5 point where the command was issued last when it reaches the RETURN command. You can have as many as one thousand different subroutines (0 - 999) and access each one as many times as you want throughout your program.

By encapsulating a piece of code into a subroutine, the code can be called upon repeatedly and from all different points throughout the rest of the program. Organizing your code into multiple subroutines is a good practice.

The commands that can conditionally direct program flow to different areas use a constant [#] like 1 or 25, a variable like a or al[#] or a function involving constants and/or variables a+b or a/[#]. Only one operator can be used in a function. A list of those operators is as follows:

+ Addition

- Subtraction

* Multiplication

/ Division

== Equals (use two =)

!= Not equal

< Less than

> Greater than

<= Less than or equal

>= Greater than or equal

& Bitwise AND (see appendix A)

| Bitwise OR (see appendix A)

WHILE, LOOP

The most basic looping function is a WHILE command. The WHILE is followed by an expression that determines whether the code between the WHILE and the following LOOP command will execute or be passed over. While the expression is true, the code will execute. An expression is true when it is non-zero. If the expression results in a “zero” then it is false. The following are valid WHILE structures:

WHILE 1 ‘1 is always true

UA=1 ‘Set output to 1

UA=0 ‘Set output to 0

LOOP ‘Will loop forever

a=1 ‘Initialize variable ‘a'

WHILE a ‘Starts out true

a=0 ‘Set ‘a' to 0

LOOP ‘This never loops back

a=0 ‘Initialize variable ‘a'

WHILE a<10 ‘a starts less

a=a+1 ‘a grows by 1

LOOP ‘Will loop back 10x

The task or tasks within the WHILE loop will execute as long as the function remains true.

The BREAK command can be used to break out of a WHILE loop, although that somewhat compromises the elegance of a WHILE statement's single test point, making the code a little harder to follow. The BREAK command should be used sparingly or preferably not at all in the context of a WHILE.

If you want a portion of code to execute only once based on a certain condition then use the IF command.

IF, ENDIF

Once the execution of the code reaches the IF command, the code between that IF and the following ENDIF will execute only when the condition directly following the IF command is true. For example:

a=UAI ‘Variable ‘a' set 0,1

a=a+UBI ‘Variable ‘a' 0,1,2

IF a==1 ‘Use double = test

b=1 ‘Set ‘b' to one

ENDIF ‘End IF

Variable b will only get set to one if variable a is equal to one. If a is not equal to one, then the program will continue to execute using the command following the ENDIF command.

Notice also that the Servida Motor language uses a single equal sign (=) to make an assignment, such as where variable a is set to equal the logical state of input A. Alternatively, a double equal (==) is used as a test, to query whether a is equal to 1 without making any change to a. These are two different functions. Having two different syntaxes has farther reaching benefits.

ELSE, ELSEIF

The ELSE and ELSEIF commands can be used to add flexibility to the IF statement. What if you wanted to execute different code for each possible state of variable a. You could write the program as follows:

a=UAI ‘Variable ‘a' set 0,1

a=a+UBI ‘Variable ‘a' 0,1,2

IF a==0 ‘Use double ‘=' test

b=1 ‘Set ‘b' to one

ELSEIF a==1

c=1 ‘Set ‘c' to one

ELSEIF a==2

c=2 ‘Set ‘c' to two

ELSE ‘If not 0, 1, or 2

d=1 ‘Set ‘d' to one

ENDIF ‘End IF

There can be many ELSEIF statements, but at most one ELSE. If the ELSE is used, it needs to be the last statement in the structure before the ELSEIF. You can also have IF structures inside IF structures. That is called “nesting” and there is no practical limit to the number of structures you can nest within one another.

SWITCH, CASE, DEFAULT, BREAK, ENDS

Long, drawn out IF structures can be cumbersome, however, and burden the program, visually. In these instances it can be better to use the SWITCH structure. The following code would accomplish the same thing as the previous program:

a=UAI ‘Variable ‘a' set 0,1

a=a+UBI ‘Variable ‘a' 0,1,2

SWITCH a ‘Begin SWITCH

CASE 0

b=1 ‘Set ‘b' to one

BREAK

CASE 1

c=1 ‘Set ‘c' to one

BREAK

CASE 2

c=2 ‘Set ‘c' to two

BREAK

DEFAULT ‘If not 0 or 1

d=1 ‘Set ‘d' to one

BREAK

ENDS ‘End SWITCH

Just as a rotary switch directs electricity, the SWITCH structure directs the flow of the program. The BREAK statement then jumps the code execution to the code following the associated ENDS command. The DEFAULT command covers every condition other than those listed. It is optional.

TWAIT Wait during trajectory

The TWAIT command pauses program execution while the motor is moving. Either the controlled end of a trajectory, or the abrupt end of a trajectory due to an error, will terminate the TWAIT waiting period. If you had a succession of move commands without this command, or similar waiting code between them, the commands would overtake each other because the program advances, even while moves are taking place. The following program has the same effect of the TWAIT command, but has the added virtue of allowing you to program other things during the wait, instead of just waiting.

WHILE Bt ‘While trajectory

LOOP ‘Loop back

WAIT=exp Wait (exp) sample periods

There will probably be circumstances where you will want to pause program execution for a specific period of time. Time, within the Servida Motor, is tracked in terms of servo sample periods. Unless otherwise programmed with the PID# command, the sample rate is about 4KHz. WAIT=4000 would wait about one second. WAIT=1000 would wait for about one quarter of a second. The following code would be the same as WAIT=1000, only it will allow you to execute code during the wait if you place it between the WHILE and the LOOP.

CLK=0 ‘Reset CLK to 0

WHILE CLK<1000 ‘CLK will grow

IF UAI==0 ‘Monitor input A

GOSUB911 ‘If input low

ENDIF ‘End the IF

LOOP ‘Loop back

The above code example will check if input A ever goes low, while it is waiting for the the CLK variable to count up to 1000.

STACK Reset the GOSUB return stack

The STACK is where information is held with regard to nesting of subroutines (nesting is when one or more subroutines exist within others). In the event you direct program flow out of one or more nested subroutines, without executing the included RETURN commands, you will corrupt the stack. The STACK command resets the stack with zero recorded nesting. Use it with care and try to build your program without using the STACK command.

One possible use of the STACK command might be if your program used one or more nested subroutines and an emergency occurred, the program or operator could issue the STACK command and then a GOTO command which would send the program back to a label at the beginning. Using this method instead of a RESET command would retain the states of the variables and allow further specific action to resolve the emergency.

3. Variables

Variables are data holders that you can set and change within the program or over the communication channel.

The first 26 variables are long integers (32 bits) and are accessed with the lower case letters of the alphabet, a, b, c, . . . x, y, z.

a=# Set variable a to a numerical value

a=exp Set variable a to value of an expression

A variable can be set to an expression with only one operator and two operands. The operators can be any of the following:

+ Addition

- Subtraction

* Multiplication

/ Division

& Bitwise AND (see appendix A)

| Bitwise OR (see appendix A)

The following are legal:

a=b+c,	a=b+3	a=5+8
a=b-c	a=5-c	a=b-10
a=b*c	a=3*5	a=c*3
a=b/c	a=b/2	a=5/b
a=b&c	a=b&8
a=b\|c	a=b\|15

Arrays

In addition to the first 26, there are 52 more long integer variables accessible with double and triple lower case letters: aa, bb, cc, . . . xxx, yyy, zzz. The memory space that holds these 52 variables is more flexible, however. This same variable space can be accessed with an array variable type. An array variable is one that has a numeric index component, that allows which variable a program changes to be selected numerically, and therefore mathematically. This memory space is further made flexible by the fact that it can hold 51 thirty two bit integers, or 101 sixteen bit integers, or 201 eight bit integers (all signed).

The array variables take the following form:

ab[i]=exp Set variable to a signed 8 bit value where index i = 0...200

aw[i]=exp Set variable to a signed 16 bit value where index i = 0...100

al[i]=exp Set variable to a signed 32 bit value where index i = 0...50

The index i may be a number, a variable a thru z, or the sum or difference of any two variables a thru z (variables only).

The same array space can be accessed with any combination of variable types. Just keep in mind how much space each variable takes. We can even go so far as to say that one type of variable can be written and another read from the same space. For example, if you assigned the first four eight bit integers as follows:

ab[0]=0

ab[1]=0

ab[2]=1

ab[3]=0

that would occupy the same space as the first single 32 bit number, and due to the way binary numbers work, would make the thirty two bit variable equal to 256 (see appendix A).

A common use of the array variable type is to set up what is called a buffer. In many applications, the Servida Motor will be tasked with inputting data about an array of objects and to do processing on that data in the same order, but not necessarily at the same time. Under those circumstances it may be necessary to “buffer” or “store” that data while the Servida Motor processes it at the proper times.

To set up a buffer the programmer would allocate a block of memory to it, assign a variable to an input pointer and another to an output pointer. Both pointers would start out as zero and every time data was put into the buffer the input pointer would increment. Every time the data was used, the output buffer would likewise increment. Every time one of the pointers is incremented, it would be checked for exceeding the allocated memory space and rolled back to zero in that event, where it would continue to increment as data came in. This is a first-in, first-out or “FIFO”, circular buffer. You need to be sure that there is enough memory allocated so that the input pointer never overruns the output pointer.

Storage of variables
(Not available in SVXXX5 Servida Motors)

Each Servida Motor has 8K of non-volatile EEPROM memory to store variables when they need to survive the motor powering down.

EPTR=expression Set EEPROM pointer, 0-7999

To read or write into this memory space you first need to properly locate the pointer. This is accomplished by setting EPTR equal to the offset.

VST(variable,index) Store variables

To store a series of variables use the VST command. In the "variable" space of the command put the name of the variable and in the "index" space put the number of variables following that variable that you also want to store. Put a one here if you only want to store the one variable specified. The actual sizes of the variables will be handled automatically.

VLD(variable,index) Load variables

To load variables, starting at the pointer, use the VLD command. In the "variable" space of the command put the name of the variable and in the "index" space put the number of subsequent variables you want loaded.

Fixed or pre-assigned functions

In addition to the general purpose variables there are variables that are gateways into the different functions of the motor itself.

@P Current position

@PE Current position error

@V Current velocity

ADDR Motor's self address

CHN0 RS-232 com error flags

CHN1 RS-485 com error flags

CLK Read/write sample rate counter

CTR External encoder count variable

I Last recorded index position

LEN # of characters in RS-232 buffer

LEN1 # of characters in RS-485 buffer

Report to host commands

Ra...Rzzz Report variable a ... zzz, 78 in all

Rab[i] Report 8 bit variable value Rab[i]

Raw[i] Report 16 bit variable value Raw[i]

Ral[i] Report 32 bit variable value Ral[i]

RA Report buffered acceleration

RAIN{port}{ch} Report 8 bit analog input port=A-H, ch= 1-4

RAMPS Report assigned maximum current

RBa Report overcurrent status bit

RBb Report parity error status bit

RBc Report communications error bit

RBd Report user math overflow status bit

RBe Report position error status bit

RBf Report communications framing error status bit

RBk Report EEPROM read/write status bit

RBl Report historical left limit status bit

RBi Report index status bit

RBh Report overheat status bit

RBm Report negative limit status bit

RBo Report motor off status bit

RBp Report positive limit status bit

RBr Report historical right limit status bit

RBs Report program scan status bit

RBt Report trajectory status bit

RBu Report user array index status bit

RBw Report wrap around status bit

RBx Report hardware index input level

RCHN Report combined communications status bits

RCHN0 Report RS-232 communications status bits

RCHN1 Report RS-485 communications status bits

RCLK Report clock value

RCTR Report secondary counter

RCS Report RS-232 communications check sum

RCS1 Report RS-485 communications check sum

RD Report buffered move distance value

RDIN{port}{ch} Report 8 bit digital input byte, port=A-H, and ch=0-63

RE Report buffered maximum pos. error

RI Report last stored index position

RKA Report buffered Kaff coefficient

RKD Report buffered Kd coefficient

RKG Report buffered Kg coefficient

RKI Report buffered Ki coefficient

RKL Report buffered Kl limit value

RKP Report buffered Kp coefficient

RKS Report buffered Ks coefficient

RKV Report buffered Kvff coefficient

RP Report measured position

RPE Report present position error

RMODE Report present positioning mode:

P Absolute position move

R Relative position move

V Velocity move

T Torque mode

F Follow mode

S Step and Direction mode

C Cam Table mode

W Drive mode

X Follow mode with multiplier

E Position error

O Motor off

H Contouring mode

RS2 Restore RS-232 mode

RS4 Assign UG to RS-485 control

RS Report status byte (8 system states)

RSP Report sample period and version number

RT Report current requested torque

RV Report velocity

RW Report status word (16 system states)

4. Encoder And Pulse Train Following

Through the two pins, A and B, of the I/O connector, quadrature or step and direction signals can be fed into the Servida Motor at high speeds and be followed by the motor itself. This feature brings about the following capabilities:

          1) Mode Follow
          2) Mode Step and Direction
          3) Mode Follow with ratio
          4) Mode Step and Direction with ratio
          5) Mode Cam

In addition to the above embedded modes of operation, the internal counter can be set to either count encoder signals or step signals and be accessible to the internal program or a host through the CTR variable.

When the Servida Motor is in one of the above five modes it may also run internal programs and communicate with a host, all at the same time.

MF1, MF2 and MF4 Mode Follow

Mode Follow allows the Servida Motor to follow an external encoder. In addition to being read in full scale (MF1), the incoming quadrature wave can be read by the internal hardware in 2x (MF2) as well as 4x (MF4) resolution.

MF0, MS0

The MF0 and MS0 commands must not be issued during one of the other follow modes. They are used for an entirely different purpose. If you do not want to directly follow an incoming encoder or step signal, but rater just want to track them and use the counter value within your own program or from a host, then issuing MF0 or MS0 utilizes the maximum resolution available and makes the value available through the CTR function. Issuing MF0 or MS0 will zero that variable and incoming encoder or step signals will increment or decrement the signed, 32-bit CTR function value.

MFDIV=expression Set Ratio divisor

MFMUL=expression SetRatiomultiplier

where -256.0000 < Ratio < 256.0000

After the appropriate MF# command is issued, or the MS command has been issued, a floating point ratio can further be applied by the firmware. Since the Servida Motor is an integer machine, that floating point ratio is accomplished by dividing one number by another.

MFR Calculate Mode Follow Ratio

MSR Calculate Mode Step Ratio

Once a numerator and denominator have been specified, and the appropriate hardware mode is selected, the motor can be put into ratio mode with the MFR or MSR commands (MSR for ratioing incoming step and direction signals). The following example sets up a 10.5:1 relationship:

MF4 ‘Read in full res.

MFMUL=2 ‘10.5:1=21:2

MFDIV=21

D=0 ‘be sure D is zero

MFR ‘Invoke calculation

G ‘Start

Once in a ratio mode the V=# and D=# commands will still work. They will invoke a phase shift of length D at a relative rate determined by V. For that reason, you must zero out D before issuing an MFR or MSR command or you could find unexpected shifting taking place. In applications such as a Web Press, this ability to phase shift can be very useful.

MC Mode Cam

A cam is a basically round but irregular shape that rotates and causes a follower to move up and down in a profile determined by the shape of the cam's exterior.

Since the beginning of industrialization, cams have been used to create complex, reciprocating motion. Cams are most often carved out of steel and changing them, or having them invoke motion a great distance away are impractical. The Servida Motor provides an electronic alternative. Putting an encoder on the rotating part of a machine, sending the signals to a Servida Motor and programming the cam profile into the Servida Motor allows for the same complex, repeating motions to be accomplished, without any of the typical mechanical limitations.

BASE=expression Base length

Part of defining a Cam relationship is specifying how many incoming encoder counts there are for one full cam rotation. Simply set BASE equal to this number.

SIZE=expression Number of Cam data entries

The upper variable array space holds the cam profile data. To instruct the Servida Motor as to how many data points you have specified, set SIZE equal to that number. The cam firmware looks at words (16 bit numbers). The maximum number of words you can use is 100. The cam firmware will perform linear interpolation between those entries, as well as between the last and the first as the cam progresses through the table and back to the beginning. The cam table entries occupy the same space as variables aa through yyy. Set the values in the following way:

aw[0]=1234

aw[1]=3456

...etc.

MD50 Drive Mode

The MD50 command causes the Servida Motor to emulate a traditional servo and amplifier so it can be used with yet another controller sending a standard +/-10Volt analog command signal. A small voltage divider is necessary to convert the +/-10 volts into the 0 to 5 volt signal the motor takes an additional device may be desired to take the single ended encoder signals coming out of the Servida Motor and make them differential for more noise immunity during their travel back to the external controller.

The following binary values can be tested by IF and WHILE control flow expressions, or assigned to any variable. They may all be reported using RB{bit} commands. Some may be reset using Z{bit} commands and some are reset when accessed. The first 8 states are reported in combination by the RS command. RW reports sixteen of these flags in combination.

By writing your program to periodically test these bits, you can make your Servida Motor application very “Servida ” about its own inner-workings and doings.

Bo Motor off status bit 7

Bh Excessive temperature status bit 6

Be Excessive position error status bit 5

Bw Wraparound occurred status bit 4

Bi Index report available status bit 3

Bm Real time negative limit status bit 2

Bp Real time positive limit status bit 1

Bt Trajectory in progress status bit 0

Ba Over current state occurred

Bb Parity error occurred

Bc Communication overflow occurred

Bd User math overflow occurred

Bf Communications framing error occurred

Bk Program check sum/EEPROM failure

Bl Historical left limit

Br Historical right limit

Bs Syntax error occurred

Bu User array index error occurred

Bx Hardware index input level

If you do take action based on some of the error flags, you will need to reset the flag in order to look out for the next occurence, or in some cases depending on how your code is written, in order to keep from acting over and over again, on the same occurence. The flags that need to be reset are listed. Their letter designator is preceded by the letter Z.

Reset system state flags

Za Reset over current violation occurred

Zb Reset parity error occurred

Zc Reset com overflow error occurred

Zd Reset user math overflow occurred

Zf Reset communications framing error occurred

Zl Reset historical left limit occurred

Zr Reset historical right limit occurred

Zs Reset syntax error occurred

Zu Reset user array index error occurred

Zw Reset wraparound occurred

ZS Reset all Z{bit} state flags

The TWAIT command pauses program execution until motion is complete. Instead of using TWAIT, a routine could be written that does much more. To start with, the following code example would perform the same function as TWAIT:

WHILE Bt ‘While trajectory

LOOP ‘Loop back

Alternatively, the above routine could be augmented with code that took specific action in the event of an index signal as is shown in the following example

WHILE Bt ‘While trajectory

IF Bi ‘Check index

GOSUB500 ‘take care of it

ENDIF ‘end checking

LOOP ‘Loop back

5. I nput and Output

The main RS-232 port

ECHO	Echo back all received characters
SADDR#	Set address (0 to 100)
SILENT	Suppress print messages
TALK	Re-activate print message
SLEEP	Ignore all commands except WAKE
WAKE	Consider all following commands
BAUD19200	Set baud rate to 19200 bps
OCHN (RS2,0,N,38400,1,8,D)	Open - No parity, 38.4k bps, 1 stop, 8 data, as Data
OCHN (RS4,0,N,38400,1,8,C)	Open as RS-485 port (with adapter) as Command
IF LEN>0	Check to see if any (or how much) data is in the 16 byte input buffer, Data mode
c=GETCHR	Get byte from buffer into variable c for Data mode
PRINT (“Char Rcd:”,c,#13)	Print text, data and ASCII code for carriage return

The G port

UGI	Redefine as general input
UGO	Redefine as general output (Open collector, pulled to 5V)
UG	Return pin to default start function, when low motor starts motion
UG=0	Set G port Low (UG=a to set to variable a)
UG=1	Set G port High (Open collector, weakly pulled to 5V internally)
a=UGI	Set variable a to digital input
a=UGA	Set a to analog input, 0 to = 0 to 5V
UCI	Redefine Right Limit as general input (UDI for Left Limit)
UCO	Redefine Right Limit as general output (UDO for Left Limit)
UCP	Return pin to limit function (UDM for Left Limit)
UC=0	Set Right Limit Low (UD=0 for Left, or UD=a to set to variable a)
UC=1	Set Right Limit High (UD=1 for Left Limit)
a=UCI	Set variable a to digital input (UDI for Left Limit)
a=UCA	Set a to analog input, 0 to = 0 to 5V (UDA for Left Limit)

Counter functions of ports A and B

MF4	Set Mode Follow with full quadrature
MFR	Set Mode Follow with ratio for gearing
MS	Mode Step and Direction
MC	Mode Cam
MF0	Set follow mode to increment counter only
MS0	Set counter mode to increment counter only
a=CTR	Set variable a to counter value

General I/O functions of ports A and B

UAI	Set port A to input (UBI for port B)
UAO	Set port A to output (UBO for port B)
UA=0	Set port A Low (UB=0 for port B, or UB=a to set to variable a)
UA=1	Set port A High (UB=1 for port B)
a=UAI	Set variable a to digital input (UBI for port B)
a=UAA	Set a to analog input, 0 to = 0 to 5V (UBA for port B)

The anilink port (using i2c protocol)

AOUTB,c	Send variable c out to Analog I/O board addressed as B
DOUTB0,c	Send variable c out to Digital I/O board addressed as B0
c=AINB2	Set variable c to input 2 from Analog I/O board addressed as B
c=DINB0	Set variable c to input from Digital I/O board addressed as B0
PRINTB(“Temp:”,c,#32)	Print to LCD on network - text, data and ASCII code

The anilink port (using rs-485 protocol)

OCHN(RS4,1,N,38400,1,8,D)	Open - No parity, 38.4k bps, 1 stop, 8 data, as data
IF LEN1>0	Check to see if any data is in the 16 byte input buffer
c=GETCHR1	Get byte from buffer into variable c
PRINT1(“Char Rcd:”,c,#13)	Print text, data and ASCII code
ECHO1	ECHO back all received characters
SILENT1	Suppress print messages
SLEEP1	Ignore all commands except WAKE
WAKE1	Consider all following commands

The anilink port as general I/O

UEI	Set port E to input (UFI for port F)
UEO	Set port E to output (UFO for port F)
UE=0	Set port E Low (UF=0 for port F, or UF=c to set to variable c)
UE=1	Set port E High (UF=1 for port F)
c=UEI	Set variable c to digital input (UFI for port F)
c=UEA	Set c to analog input, 0 to = 0 to 5V (UFA for port F)
	Ports E and F have internal 5k Ohm resistive pull-ups

The Servida Motor brings out 5 volt power and ground, as well as seven I/O points. Each one has multiple functions. They are UA, UB, UC, UD, UE, UF and UG and have the following functions:

UA Digital Input, TTL, 0 to 5 volts