This post provides a simple function block example that opens a connection to the Galil Controller, then sends commands and receives the responses at 1 second intervals.  This code allows for basic communication from the TwinCAT PLC to a Galil Controller.  The full project can be found here:

http://www.galilmc.com/support/techtalk_files/TwinCAT_TCP.zip

The code is shown below:

The IP address and command sent to the controller are defined in the MAIN (PRG) as i_sRemoteHost and sSendCommand respectively.

PROGRAM MAIN
VAR
lrVar1: LREAL := 123.45;
fbGalil: FB_Galil;
tUpdate: TIME := T#1s;
xEnable: BOOL := TRUE;
sSendCommand: STRING := 'MG TIME';
END_VAR

————————————————————–

(* P_simple_TCPIP(); *)

fbGalil(
i_xEnable:= xEnable,
i_sSrvNetID:= '',
i_sRemoteHost:= '192.168.1.74',
i_nRemotePort:=23 ,
i_tReconnect:= T#5s ,
i_tUpdateTime:= tUpdate,
lrVar1:= lrVar1,
lrVar2:=0,
sSendCommand:=sSendCommand );

The communication is handled in the FB_Galil (FB) Function Block - code is shown below.

FUNCTION_BLOCK FB_Galil
VAR_INPUT
i_xEnable            :BOOL;
i_sSrvNetID         :STRING := '';
i_sRemoteHost     :STRING;
i_nRemotePort     :UDINT;
i_tReconnect       :TIME := t#45s;
i_tUpdateTime      :TIME := T#1s;

lrVar1                :LREAL;
lrVar2                :LREAL;
sSendCommand    :STRING;
END_VAR
VAR_OUTPUT
END_VAR
VAR
fbClientServerConnection: FB_ClientServerConnection;
fbSocketSend: FB_SocketSend;
sSendString: STRING;
fbSocketReceive: FB_SocketReceive;
iStep: INT;
rtEnable: R_TRIG;
tonUpdate: TON;
sReceiveString: STRING;
END_VAR

—————————————————————-

rtEnable(CLK:=i_xEnable);

IF i_xEnable = FALSE THEN
iStep := 0;
END_IF

CASE iStep OF
0: (* idle *)
fbClientServerConnection.bEnable:= FALSE;
fbSocketSend.bExecute := FALSE;
fbSocketReceive.bExecute := FALSE;
IF i_xEnable = TRUE THEN
iStep := 10;
END_IF

10: (* make the conection *)
fbClientServerConnection.bEnable:= TRUE;
IF fbClientServerConnection.eState = eSOCKET_CONNECTED THEN
iStep := 100;
ELSIF fbClientServerConnection.bError THEN
iStep :=0;
END_IF

100:
IF tonUpdate.Q THEN
fbSocketSend.bExecute := FALSE; (* reset send*)
fbSocketReceive.bExecute := FALSE; (*reset receive *)
iStep := 110;
tonUpdate(IN := FALSE);  (* reset timer *)
END_IF

110:
(* command to just set a variable - this would be commanded moves as well (ie PA, BG etc) *)
(*
sSendString := 'var1=TIME';
(* append a number to a variable decleration - ie var1=123.45 *)
(*        sSendString := 'var1=';
sSendString := CONCAT(sSendString,LREAL_TO_STRING(lrVar1)); *)
sSendString := CONCAT(sSendString,'$r');(*append carriage return and line feed*)
fbSocketSend.pSrc:= ADR(sSendString);
fbSocketSend.cbLen := LEN(sSendString);
fbSocketSend.bExecute := TRUE;
*)

(* command with a response *)
sSendString := sSendCommand;
sSendString := CONCAT(sSendString,'$r$n');(*append carriage return and line feed*)
fbSocketSend.pSrc:= ADR(sSendString);
fbSocketSend.cbLen := LEN(sSendString);
fbSocketSend.bExecute := TRUE;
iStep := 120;

120:
IF NOT fbSocketSend.bBusy THEN
IF NOT fbSocketSend.bError THEN
iStep := 125;
ELSE
(* hanldle error *)
iStep := 9000;
END_IF
END_IF

125:
(*clear memory for receive string and set receive to true *)
MEMSET(destAddr:=ADR(sReceiveString), fillByte:=0, n:=SIZEOF(sReceiveString));
fbSocketReceive.bExecute := TRUE;
iStep := 130;

130:
(* read receive data *)
fbSocketReceive.pDest := ADR(sReceiveString);
fbSocketReceive.cbLen := SIZEOF(sReceiveString) - 1;
iStep := 140;

140:
(* check to see if received data - if not, read again (130) *)
IF NOT fbSocketReceive.bBusy THEN
IF NOT fbSocketReceive.bError THEN
IF fbSocketReceive.nRecBytes > 0 THEN
iStep := 100;
ELSE
fbSocketReceive.bExecute := FALSE; (*reset receive *)
iStep := 125;
END_IF
ELSE
(* hanldle error *)
iStep := 9000;
END_IF
END_IF

9000: (* error step *)
iStep:=0;

END_CASE

fbClientServerConnection(
sSrvNetID:= i_sSrvNetID,
nMode:= CONNECT_MODE_ENABLEDBG,
sRemoteHost:= i_sRemoteHost,
nRemotePort:= i_nRemotePort,
tReconnect:= i_tReconnect    );

fbSocketSend(
sSrvNetId:='' ,
hSocket:= fbClientServerConnection.hSocket,
tTimeout:= t#2s);

fbSocketReceive(
sSrvNetId:='' ,
hSocket:= fbClientServerConnection.hSocket,
tTimeout:= t#2s);

tonUpdate(IN := TRUE, PT:= i_tUpdateTime);

AMP-435×0 2- and 4-axis 600 W Servo Drives with Sine Commutation (-D3520, -D3540)

The AMP-43540 contains four transconductance, PWM amplifiers for driving brushed or brushless servo motors with sinusoidal commutation and the AMP-43520 contains two PWM amplifiers. Each amplifier drives motors operating at up to 8 Amps rms cont.,   15 Amps peak, 20–80 VDC.
The gain settings of the amplifier are user-programmable at 0.4, 0.8 and 1.6 Amp/Volt. The switching frequency is 33 KHz. The amplifier offers protection for over-voltage, under-voltage, over-current, short-circuit and over-temperature. Hall sensors are not required for brushless motor commutation.  A shunt regulator option is available.

SDM-440×0 2- and 4-axis Stepper Drives (-D4020, -D4040)

The SDM-44040 contains four drives for operating two-phase bipolar step motors and the SDM-44020 contains two stepper drives. The SDM-440×0 requires a single 12–30 VDC input. The unit is user-configurable for 1.4 A, 1.0 A, 0.75 A, or 0.5 A per phase and for full step, half-step, 1/4 step or 1/16 step.

Highlights of DMC-40×0 and DMC-41×3 Series

The DMC-40×0 Accelera and DMC-41×3 Econo motion controllers are available in 1-through 8-axis formats, and each axis is user configurable for stepper and servo motor operation. The controllers are available as a controller-only model for interface to external drives of any power range or as a controller packaged with an integrated stepper or servo drive. Drive options for the DMC-40×0 and DMC-41×3 controllers are the same and are listed in Table 2.

Standard features of the DMC-40×0 and DMC-41×3 controllers include PID compensation with velocity and acceleration feed forward, memory for user programs, multitasking for simultaneously running up to eight programs, and I/O processing for synchronizing motion with external events. Modes of motion include point-to-point positioning, position tracking, jogging, linear and circular interpolation, contouring, electronic gearing, ECAM, and PVT. The DMC-40×0 Accelera controller uses a faster version of the microprocessor allowing the controller to achieve 40 microsecond command processing, accept encoder inputs up to 22 MHz, and perform servo loop updates at 62 microseconds.
Standard isolated inputs of the DMC-40×0 and DMC-41×3 controllers include forward and reverse limits for each axis and a home input for each axis. 1-through 4-axis models include 8 isolated, digital inputs and 8 isolated, digital outputs. 5 through 8-axis models include 16 inputs and 16 outputs.
Like all Galil controllers, the DMC-41×3 controllers are programmed with Galil’s intuitive, 2-letter command language, making them easy to program. Galil’s command language has used the same 2-letter format for over 25 years and is similar across both single and multi-axis controller platforms. The GalilTools and new GalilSuite software simplifies system set-up with automated servo tuning and real-time display of motion information in the time domain.
For complete pricing and specifications for the DMC-41×3 series, see:

http://www.galilmc.com/products/dmc-41×3.php

and for the DMC-40×0 Accelera series see:

http://www.galilmc.com/products/dmc-40×0.php

• View Entire ServoTrends Newsletter (Printer Friendly)Back To ServoTrends

April 2012 Featured Articles

• New Options for DMC-30000 Pocket Motion Controller Series

• New! 2-Axis Servo & Stepper Drives for DMC-41×3,-40×0 Controllers

DMC-30017 Motion Controller with 6A, 80V Microstepping Drive
The DMC-30017 contains a microstepping drive for operating a two-phase bipolar stepper motor. The drive produces 256 microsteps per full step or 1024 steps per full cycle which results in 51,200 steps/rev for a standard 200-step motor. The maximum step rate generated by the controller is 3,000,000 microsteps/second. The DMC-30017 drives motors operating at up to 6 Amps at 20 to 80 VDC.
There are four software-selectable current settings: 0.75A, 1.5A, 3 A, and 6A. A selectable low-current mode reduces the current by 75% when the motor is not in motion. No external heatsink is required.

DMC-31xxx Option for 16-bit ADC and Sinusoidal Encoder

The DMC-31xxx model increases the ADC resolution from 12-bits to 16-bits and provides +/-10V configurable analog inputs, and provides an option for accepting sinusoidal encoder signals instead of digital encoder signals. The DMC-31xxx interpolates a 1-volt differential sinusoidal encoder resulting in a higher position resolution. The AFn command selects sinusoidal interpolation where n specifies 2^n interpolation counts per encoder cycle (n=5 to 12). For example, if the encoder cycle is 40 microns, AF10 results in 2^10=1024 counts per cycle, or a resolution of 39 nanometers per count.

Highlights of DMC-30000 Series

High performance features of the DMC-30000 include: 125 microsecond servo loop update period, 15MHz encoder frequency, non-volatile memory for user programs, and multitasking for simultaneously running up to four user programs.  Modes of motion include point-to-point positioning, position tracking, jogging, contouring, electronic gearing, ECAM, and PVT. The DMC-30000 includes two 100Base-T Ethernet ports in addition to an internal Ethernet hub which allows multiple units to be daisy-chained without the use of an external hub.
The DMC-30000 provides optically isolated inputs and outputs as a standard feature including forward and reverse limit inputs, homing input, 8 uncommitted digital inputs, 4 uncommitted digital outputs, 2 uncommitted analog inputs and 1 uncommitted analog output.  The DMC-30000 accepts both main and auxiliary quadrature encoders as standard, with BiSS and SSI formats available as an option. The new DMC-31xxx option accepts sinusoidal encoder inputs instead of digital inputs and provides a 16-bit analog-to-digital converter instead of 12-bit ADC.
The DMC-30000 single-axis controller series is available as a controller-only for connection to external motor drives of any power range or it can be purchased as an integrated controller and drive package. The DMC-30012 model is a controller packaged with an internal 800W sine drive for operating brushed/brushless motors at 20-80 VDC, up to 10 Amps rms continuous, 15 Amps peak. The DMC-30017 model is a controller packaged with an internal 20-80 VDC, 6A/phase microstepping drive.
The Pocket Motion Controller Series is compact in size, measuring just 3.9” x 5.0” x 1.5” for the DMC-30012/30017 controller/drive package and 3.0” x 4.0” for the controller-only card. The series is also economically priced for OEMs: $445 in quantities of 100 for the DMC-30012 controller with 800W brushless sine drive.
Like all Galil controllers, the DMC-30000 is programmed with Galil’s intuitive, 2-letter command language, making it quick and easy to program. Galil’s command language has used the same 2-letter format for over 25 years and is similar across both single and multi-axis controller platforms. The GalilTools and new GalilSuite software simplifies system set-up with automated servo tuning and real-time display of motion information in the time domain.
Currently available models and options for the DMC-30000 Pocket Motion Controller Series are listed in Table 1.

Complete pricing and specifications for the DMC-30000 Pocket Motion Controller Series, are available at: http://www.galilmc.com/products/dmc-300xx.php or contact a Galil application engineer at 800-377-6329 or support@galilmc.com

• View Entire ServoTrends Newsletter (Printer Friendly)Back To ServoTrends

April 2012 Featured Articles

• New Options for DMC-30000 Pocket Motion Controller Series

• New! 2-Axis Servo & Stepper Drives for DMC-41×3,-40×0 Controllers

1. BZ/BX method
2. BI Method

____________________________________________________________________________________
BZ/BX method:

This method is the recommended method to initialize the motor, as it requires the least number of steps and provides reliable initialization with the option of minimal movement. Both BZ and BX do not require any additional connections other than the encoder signals to the controller and the motor phases to the drive.

1. Connect the motor and encoder to the DMC controller.
2. Connect to the controller using Galiltools software. Check encoder position with the TP command and ensure that the encoder is working.
3. Move the motor manually in the desired positive direction while monitoring TP.
   • If TP is decreasing, issue CE2 to invert the direction. Alternatively, swap A+/A- encoder leads on a differential encoder, or A/B on a single-ended encoder.
4. Enable sine amps (BA)
5. Set brushless modulus (BM. This value is the counts/revolution of the motor divided by the number of pole pairs of the motor. For a linear motor, it is the number of encoder counts per magnetic phase.
6. Initialize motor (BZ or BX). Ensure that the command voltage for BZ/BX is sufficient to move the motor.
   • If the error “BZ runaway” or “BX failure” occurs, swap motor leads A and B and reissue BZ/BX.
   • If the error “BZ timeout” occurs, try increasing the timeout time with the BZ<t command. t defaults to 1000msec.
7. Servo the motor and test commutation by jogging the motor slowly. If the motor stalls, cogs or runs away, swap motor leads A and B and re-issue BZ/BX
8. The motor is now wired for sine commutation using BZ/BX.

____________________________________________________________________________________
BI Method:

BI initialization used the motors hall sensors to initialize the brushless degrees of the motor. This requires additional steps and considerations when wiring in order to ensure proper configuration, and is not recommended for most applications. This is useful when dealing with a non-linear load, or when initializing a vertical stage.

To work, the halls must be wired into the controller along with the motor phases and the encoder signals. The hall inputs must be aligned so that Hall A aligns with Motor A-B, hall B aligns with Motor B-C, and Hall C aligns with Motor C-A. The halls must also be counting up when the motor is moving in the positive direction. Setting up the motor for BI initialization will require potential wiring changes to both the motor leads and the hall inputs. The following steps will help ensure that the correct configuration is reached.

Notes: The motor must have standard hall sensors. That means when the motor is at phase A, hall A is high. If hall A is low when at phase A, your halls are inverted.

The AMP-43640 does not support BI-1, but can still support hall initialization using general inputs. See the BI command for more information. To query hall state, use _BCx rather than QH.

1. Connect the motor and encoder to the DMC controller.
2. Connect to controller with Galiltools software. Check encoder position (TP) and Hall State (QH) and ensure that both are changing and connected correctly.
3. Enable sine amps (BA).
4. Set brushless modulus (BM). See previous section for explanation.
5. Move the motor slowly in the desired positive direction while monitoring TP.
   • If TP is decreasing, issue CE2 to account for incorrect encoder direction. Alternatively, swap A+/A- encoder leads on differential encoder, or A/B on a single-ended encoder.
6. Check the hall transitions by monitoring QH/Hall State while slowly spinning in the positive direction. Halls should be counting in the following order: 1 3 2 6 4 5
   • If the order is reversed, swap Hall A and C. If you aren’t getting all 6 states, one of the hall inputs is mis-wired or not connected.
7. Initialize the motor for hall commutation (BI-1).
8. Servo the motor and test for closed loop. If motion works, skip to step 9
   • If the motor runs away/stalls, then issue an MO and try initialization using BZ. If the motor stalls/cogs or runs away after BZ, swap motor phases A and B and retry step 7.
   • After BZ, check the hall state with QH. If QH shows either of the two values, then rewire the motor based on the following, and then retry step 7
     • QH=5: Swap Motor AB, then motor BC
     • QH=6: Swap Motor AC, then motor BC
9. The motor should now be wired for sine commutation using BI. Once you have servo control, you can enable sine commutation by issuing the BC command and commanding a slow Jog move. Once a hall transition is found, the commutation will be calculated based on the transistion.

____________________________________________________________________________________
Galil is here to help you get up and running with our controller and drive as quickly and smoothly as possible. If you have any questions about this, please contact our Applications department at (800)377-6329 or contact support@galilmc.com.

In the output below, the motor was intentionally shut off using an MO command to cause an error to occur and then turned back on using an SH via Ethernet.  Here is the output from the terminal:
$:
$:GO
Motion Starting
$:STOP
Motion Stopping
$:GO
ERROR  20.0000
$:GO
Motion Starting
$:STOP
Motion Stopping

Here is the .dmc code:

#Main

CI 1,1; ‘interrupt on c/r

CW2; ‘ASCII readable MG output

#Loop

JP#Loop

EN

#COMINT

JS#PARSE

EN1,1

#PARSE

‘routine to parse input

str=P1ST;

IF (str=”GO”)

JS#GO

ENDIF

IF (str=”STOP”)

JS#STOP

ENDIF

MG{P1}”$:”{N}

EN

#GO

JG 1000; BGA;

MG{P1}”Motion Starting”

EN

#STOP
STX;

MG{P1}”Motion Stopping”

EN

#CMDERR

MG{P1}”ERROR “,_TC1

ZS

JP#Main

RE

]]> http://www.galilmc.com/techtalk/dmc-programming/serial-port-command-interpreter/feed/ http://www.galilmc.com/techtalk/software/infinite-array-record-over-ethernet/ http://www.galilmc.com/techtalk/software/infinite-array-record-over-ethernet/#comments Tue, 28 Feb 2012 01:27:07 +0000 Galil_DJR http://www.galilmc.com/techtalk/?p=186 This article provides a sample project demonstrating a method to record indefinitely from a controller by uploading subsets of data from a free running circular array record using the RC/RD/RA commands.

With this method, only the host PC’s hard drive is the limiting factor for the amount of data that can be stored.

Concepts

• Lowered TM
• Array Record, RC/RD/RA
• Array upload via QU command

Details/Special Instructions

• VB 2010 Express, Console App
• GalilTools 1.6.0.460
• Install GalilTools before using Demo (This installs and registers the Galil COM component)
• This Demo was tested on a 4123 and uses TM125 and an array of 16000 elements. This provides a sampling frequency of 4 KHz.
• A “Verify” project is included to read in large files and verify all data was captured without dropped samples. This project can be used as a starting point for dealing with the file output of the “infinite” array.

Download

Concepts

• unsolicited messages over TCP (in lieu of default UDP)
• the onMessage() event
• routing messages with the {En} notation in the MG command
• moving remote handles with the HS command
• multiple GalilTools COM objects
• connecting with special options

Details/Special Instructions

• VB 2010 Express
• GalilTools 1.6.0.460
• Install GalilTools before using Demo (This installs and registers the Galil COM component)
• 3 Ethernet handles are required for this approach. This demo requires an 8 handle controller because it configures the message handles to G and H.

Download

There are times, however, when the onMessage() function is not desirable. This can be due to a programming environment’s lack of support or inconvenient implementation of events. It can also be due to a programmer’s desire to use strictly procedural programming and skip over the use of events.

When using Ethernet-based communications there is a simple method for opening an extra connection and using the read() function to receive messages waiting in the driver’s input buffer. The example below takes this approach one step further and opens up yet another connection to the controller to receive a second channel of messages. With the following example there are two streams of messages which can be used, for example, for data collection and for user messages.

The code running on the controller can decide where to send the data with the brace routing notation, for example:

MG"I am G"{EG};' Sends data to channel one (m1)
MG"I am H"{EH};' Sends data to channel two (m2)

Module Module1
    Sub Main()
        'Command and response handle
        Dim g As New Galil.Galil
        g.address = "192.168.1.5 -mg 0 -ei 0 -dr 0"

        'message handle one
        Dim m1 As New Galil.Galil
        m1.address = "192.168.1.5 -s"
        m1.command("HSS=G") 'set this handle to handle G. This object will receive messages of the form MG"The Message"{EG}

        'message handle two
        Dim m2 As New Galil.Galil
        m2.address = "192.168.1.5 -s"
        m2.command("HSS=H") 'set this handle to handle H. This object will receive messages of the form MG"The Message"{EH}

        g.command("CW2") 'Do not set most significant bit of messages. Read() reads raw, so we don't want this flag
        g.programDownload("MG""I am G""{EG};MG""I am H""{EH};WT1000;JP0;EN") 'sample program
        g.command("XQ") 'start the program

        Console.WriteLine(g.connection)
        Dim string1 As String = ""
        Dim string2 As String = ""
        Dim timer As New Stopwatch
        timer.Start()
        While (timer.Elapsed.Seconds < 5)
            string1 = m1.read()
            If string1.Count <> 0 Then
                Console.WriteLine("m1 read " + string1.Count.ToString + " bytes" + vbCrLf + string1)
            End If
            string2 = m2.read()
            If string2.Count <> 0 Then
                Console.WriteLine("m2 read " + string2.Count.ToString + " bytes" + vbCrLf + string2)
            End If
        End While
        timer.Stop()
        g.command("ST")
    End Sub
End Module

192.168.1.5 -ei 0 -mg 0 -dr 0, DMC4040 Rev 1.1d1, 5254, IHB
m1 read 8 bytes
I am G

m2 read 8 bytes
I am H

m1 read 8 bytes
I am G

m2 read 8 bytes
I am H

m1 read 8 bytes
I am G

m2 read 8 bytes
I am H

m1 read 8 bytes
I am G

m2 read 8 bytes
I am H

m1 read 8 bytes
I am G

m2 read 8 bytes
I am H

m1 read 8 bytes
I am G

m2 read 8 bytes
I am H

Controller is connected to OPTO-22 via handle F. The OPTO-22’s IP address is 131.29.50.30. The Rack has the following configuration:

Digital Inputs Module 1

Digital Outputs Module 2

Analog Outputs (+/-10V) Module 3

Analog Inputs (+/-10V) Module 4

Instruction	Interpretation
#CONFIG	Label
IHF=131,29,50,30<502>2	Establish connection
WT10	Wait 10 milliseconds
JP #CFGERR,_IHF2=0	Jump to subroutine
JS #CFGDOUT	Configure digital outputs
JS #CFGAOUT	Configure analog outputs
JS #CFGAIN	Configure analog inputs
MBF = 6,6,1025,1	Save configuration to OPTO-22
EN	End
#CFGDOUT	Label
MODULE=2	Set variable
CFGVALUE=$180	Set variable
NUMOFIO=4	Set variable
JP #CFGJOIN	Jump to subroutine
#CFGAOUT	Label
MODULE=3	Set variable
CFGVALUE=$A7	Set variable
NUMOFIO=2	Set variable
JP #CFGJOIN	Jump to subroutine
#CFGAIN	Label
MODULE=5	Set variable
CFGVALUE=12	Set variable
NUMOFIO=2	Set variable
JP#CFGJOIN	Jump to subroutine
#CFGJOIN	Label
DM A[8]	Dimension array
I=0	Set variable
#CFGLOOP	Loop subroutine
A[I]=0	Set array element
I=I+1	Increment
A[I]=CFGVALUE	Set array element
I=I+1	Increment
JP #CFGLOOP,I<(2*NUMOFIO)	Conditional statement
MBF=6,16,632+(MODULE*8),NUMOFIO*2,A[]	Configure I/O using Modbus function code 16 where the starting register is 632+(MODULE*8), number of registers is NUMOFIO*2 and A[] contains the data.
EN	end
#CFERR	Label
MG”UNABLE TO ESTABLISH CONNECTION”	Message
EN	End

Using the equation:

I/O number = (Handlenum*1000) + ((Module-1)*4) + (Bitnum-1)

MG @IN[6001] display level of input at handle 6, module 1, bit 2

SB 6006 set bit of output at handle 6, module 2, bit 3

or to one

OB 6006,1

AO 608,3.6 set analog output at handle 6, module 53, bit 1 to 3.6 volts

MG @AN[6017] display voltage value of analog input at handle6, module 5, bit 2

Part I - Standard Communication

1) Opening a Socket

Most programming languages that have an Ethernet interface have an “OpenSocket” type of function that will handle establishing the UDP or TCP/IP connection.  The arguments will usually be the IP address of the device you are connecting to as well as a port number.  For a standard connection to a Galil controller, the user should connect on port number 23 (Telnet).  Other port numbers are allowed such as those above port 1000 when needed for special applications.  See the IK command for more info.

2) Sending a Command

Once a socket is established, the user will need to send a Galil command as a string to the controller (via the opened socket) followed by a Carriage return (0×0D).

3) Receiving a Response

The controller will respond to that command with a string.  The response of the command depends on which command was sent.  In general, if there is a response expected such as the “TP” Tell Position command.  The response will be in the form of the expected value(s) followed by a Carriage return (0×0D), Line Feed (0×0A), and a Colon (:).  If the command was rejected, the response will be just a question mark (?) and nothing else.  If the command is not expected to return a value, the response will be just the Colon (:).

4) Closing the Socket

The socket should be left open during general operation to send/receive commands.  In order to close the connection, the programming language should have a “CloseSocket” that will close the TCP/IP connection to the controller.

Notes:

1) A single command should not exceed 80 characters, however multiple commands can be grouped together in a single packet by separating them with semicolons.

2) Packet size should not exceed 450bytes

3) See the Appendix of the Application Note to see example packets of sending commands and receiving responses

For the complete Application Note including part 2 on Advanced Communication, go here:

http://www.galilmc.com/support/appnotes/software/note4434.pdf