Servo Motor System Components

• Brush or Brushless Servo Motor
• Encoder / Feedback Device
• Servo Motor Amplifier / Drive
• Servo Motor Controller

Brush / Brushless Motor

The choice of what motor to use is usually an early step in the process of selecting a servo system.  The critical things to be aware of are the desired speed (RPMs or Revolutions Per Minute) and the desired torque.  Many times a speed-torque curve will be available for a motor that shows the amount of torque that a motor has at a specific speed.  Servo motors generally have a relatively flat speed torque curve in that the amount of torque the motor has available stays relatively constant up until you reach the maximum speed of the motor.  (A stepper motor on the other hand can have a significant ramp where the torque drops off considerably as the speed gets higher.).  A gear-head or mechanical gear-train can be used to increase the torque of a motor when necessary.

Encoder / Feedback Device

An encoder is a position sensor that outputs a signal telling the controller where the motor is and how fast it is moving.  Many servo motors come with an encoder built in however it is also possible to use an external encoder or feedback device to control a motor.  When using an external encoder, it is critical that there not be an excessive amount of compliance between the motor and the encoder.  Essentially, any change in the motor position should immediately be detected by the encoder.  A situation where the encoder is mounted after a belt drive will cause problems due to the compliance in the belt.  In a system where the position of the load is required, it is recommended to use two encoders - one directly on the back of the motor and a second encoder on the “load”.  The Galil controller has built in functionally called “dual-loop” mode to control a system with two feedback devices.

Servo Motor Amplifier / Drive

A servo motor amplifier takes a control signal from the motor controller and amplifies it up to deliver a specific amount of power to the motor.  There are a number of different types of servo amplifiers out there but a common one is called a “torque-mode” amplifier.  This type of amplifier converts the command signal from the controller into a specific amount of current (in Amps) delivered to the motor.  In a rotary motor - current is directly proportional to torque - so the amplifier is actually directly controlling the amount of torque on the motor.  In a linear motor, current is proportional to force - so likewise the amplifier is directly controlling the amount of force coming out of the motor.  The amplifier closes a current loop around the motor at a very fast rate so that the motor controller’s command signal closely matches the actual current that is delivered to the motor.

Servo Motor Controller

Up to this point, the components explained above can essentially take in a control signal and deliver a specific amount of current to a motor - the motor will then turn and the amount that it turns can be seen by the encoder.  The job of the servo motor controller (or commonly referred to as the motion controller) is to close the loop on the system by constantly looking at the encoder signal and applying a torque to the motor in order to control it.  The simplest form of this is to hold a specific position.  In this scenario, if a disturbance causes the motor to move off of a position - the encoder detects this change in position - creating an error signal.  This error signal is then translated into a commanded current by the controller in order to drive the motor back to the original position.  A more advanced case is when the controller wants to move the motor to a new position.  In this case the controller creates a desired motion profile using a specific acceleration, deceleration, and speed.  In a very fast loop, the controller commands a specific position for the motor at a precise time - this results in the motor rotating along the desired motion profile.

Conclusion

Galil offers a wide variety of motion controllers for servo systems.  To make things easy, Galil also offers a variety of optional plug-in amplifiers that mate up directly to the controller.  There are two series of motion controllers that offer this - one is the high-performance “Accelera” series shown here:
http://www.galilmc.com/products/dmc-40×0.php
and the other is the more cost-effective “Econo” series shown here:
http://www.galilmc.com/products/dmc-21×3.php

The Galil BiSS interface is a standard upgrade option for the following controllers:

• DMC-40×0 10/100Base-T Ethernet/RS232 Accelera Series 1-8 axis
• DMC-21×3 10Base-T Ethernet/RS232 Econo Series 1-8 axis
• RIO-47xxx 10/100Base-T Ethernet Intelligent I/O Controller
• DMC-18×6 PCI Accelera Series 1-8 axis
• DMC-18×2 PCI Econo Series 1-4 axi
• CDS-3310 10/100Base-T Ethernet/RS232 1 axis controller with 500W servo drive

Galil supports a point to point unidirectional BiSS interface.  Each BiSS encoder is wired directly to the Galil controller, and the controller addresses each individual encoder independently.

Galil has supported single-turn and multi-turn rotary and linear absolute encoders from the following companies

• Renishaw Resolute
• Hengstler Absolute BiSS encoders (AD/AC series)

If your encoder is not on the above list, please contact Galil to speak with an Application Engineer to discuss your application.

For more information on the BiSS protocol - http://www.biss-ic.de/

http://www.galilmc.com/techtalk/software/how-to-create-a-custom-class-library-with-galiltools/

we created a new custom class that was able to access the RIO Data Record and parse it.  In this article, we will use the class that was created (RIO_DataRecord.cs) and show how to include it into a new C# application.  First create a new C# project and call it RIO_DR_class_demo as shown here:

Copy the class file created in the previous TechTalk article (named RIO_DataRecord.cs) and put the class file into the folder where your solution is located.

Add the RIO Data Record Class file to Solution Explorer by clicking “Project ->Add Existing Item” and choosing the RIO_DataRecord.cs file.  You should now see the file in the Solution Explorer as part of the project.

Double Click on the Form to get to the “Code View”.

Click on Project->Add Reference and click on the COM tab.  Add the Galil component. (Must have GalilTools or GalilTools Lite installed) (Select -> OK)

Add a label to the form and a Button.  Change the text of the button to Get Sample Time. Add a textbox to the form. Delete the default text in the textbox and the label so they are blank.

At the top of the code, we need to add the namespace that is called out in the class file so add the following:

using RIO_DataRecord_namespace;

Then add

private Galil.Galil g = new Galil.GalilClass();
private RIO_DataRecord r;

private const int RIO_ANALOGIO_CHANNELS = 8;

inside the public class Form1  above the public Form1()

The code should look something like this:

Add the following code to the Form1_Load():

try
{
g.address = "";  //open connection Dialog.
label1.Text = label1.Text + g.connection() + "\r\n";
label1.Text = label1.Text + g.commandValue("MG TIME").ToString();

r = new RIO_DataRecord(ref g);
r.AnIn = new ushort[RIO_ANALOGIO_CHANNELS];
r.AnOut = new ushort[RIO_ANALOGIO_CHANNELS];

}
catch (System.Runtime.InteropServices.COMException ex)
{
label1.Text = label1.Text + ex.Message.Trim() + “\r\n”;
}
Double click on the button and add the following code to the button click
r.GetRecord(g);
textBox1.Text = r.SampleNumber.ToString();

Save your project.  It should look something like this:

Run it and it should prompt you with a connection dialog.  Click on the controller and hit Connect:

Click on the “Get Sample Time” button to get the current sample time using the RIO_DataRecord class.

That has successfully used the class to grab information out of the RIO data record.  An optional step is to then add another label to the form and include the following code in the button click in order to display all of the RIO data record information:

string str="", AO="",AI="";
str="Header bytes in Hex = "+r.Header.ToString("X")+"\r\n"+
"Sample Number = "+r.SampleNumber.ToString()+"\r\n"+
"Error Code = "+ r.ErrorCode.ToString()+"\r\n"+
"General Status = " + r.GenSatus.ToString()+"\r\n";
for (int i = 0; i < 7; i++)
{
AO=AO+r.AnOut[i].ToString()+”  “;
}

str=str+”Analog Outputs = “+AO+”\r\n”;
for (int i = 0; i < 7; i++)
{
AI=AI+r.AnIn[i].ToString()+”  “;
}
str=str+”Analog Inputs = “+AI+”\r\n”;
str=str+ “Digital Outputs = “+ r.DOut.ToString()+”\r\n”+
“Digital Inputs = ” + r.DIn.ToString()+”\r\n”+
“Pulse Counter = ” + r.PulseCount.ToString()+”\r\n”+
“ZC Data = “+ r.ZcData.ToString()+”\r\n”+
“ZD Data = “+r.ZdData.ToString();
label2.Text = str;

The result will look something like this:

The last thing to do is to use the ZC property that was created in the class.   You simply need to add the following code at the top of the button click:

r.ZC = "12";

That will send a value of 12 to the ZC command and the ZC Data in the data record should also reflect the change.

That completes the application code showing how to interface to a custom class from a C# application.  Creating a custom class allows the user to expand the functionality of the GalilTools API and gives the programmer the ability to create routines that can optimize code.  Contact a Galil Applications Engineer for more info on writing custom classes and interfacing them to a .NET application.

Label1.Text=g.commandValue(”MG@AN[1]“)

Where g represents an object that holds the “Galil” class from the GalilTools Class Library. This will populate Label1 with the value of the response to the command that was sent. Similarly, the A axis actual position could be read using a similar structure:

Label1.Text=g.commandValue(”TPA”)

so it is possible to quickly and easily get access to any Galil command using the g.commandValue( _ ) format.  However, it is also nice to get to the same information using a call such as:

Label1.Text = r.AnIn[1]

So , for more complex applications where there could be numerous queries to many different commands - it may be desirable to streamline communication - and therefore it is best to grab the information in one big “snapshot” and then parse that information out as opposed to grabbing each individual item one at a time. Enter the controllers Data Record - this is similar to a memory map of the controller that can be sent out of the controller as one big packet and then leverages the software running on the PC to provide access to the desired information. In this way, the communication can be made more efficient by requiring less individual queries for items that are contained in the Data Record.

A second problem with the first method shown above is that it requires the programmer to get the command syntax correct every time they request a piece of information. If they enter the wrong string for the g.command( _ ) call, then the program will fail at runtime - but there is no indication that anything is wrong when writing the program. To solve these issues, a custom “Class” library can be used that packages the programmers functions and data requests into a more manageable format.  The goal of the class will be to create a method that will allow us to get the DataRecord information into an object and also to create a property that has read/write capability.  As an example we will be working with the RIO hardware but the same type of programming can be applied to any Galil controller.

We’ll use the C# programming language but the same idea applies for other languages as well. Open Visual Studio and create a new Class Library file. Visual Studio starts out with a namespace, a class called Class1 and the constructor called Class1( ). The “constructor” Class1( ) will run when the class is first created - it can be thought of as the initialization routine. Keep this in mind as we will refer to it later in the article.

There are three main things that are used in classes - methods, properties, and events.  Methods are essentially subroutines that can have a return value and optionally a list of parameters that can be passed in and out of the routine.  Properties are essentially variables or values that are stored as part of the class.  Lastly - events can be created in order to alert the main program when something happens.  In this article we’re going to stick with the first two - methods and properties.

So, after all that - lets get to something useful.  The goal here is to write a class that will allow access to the RIO Data Record.  This way, the information in the data record can be read in a simpler format than specifying the Galil command every time the data is requested.  Here is an example of how we will be grabbing the sample time from the data record in the new format:
textBox1.Text = r.SampleNumber.ToString();
(note: the .ToString() is to convert the value from an integer to a string for display purposes)

First, I’ll show the entire class definition and then we will break it up and discuss each section.  Here’s the entire class:

using System;
using System.Text;

namespace RIO_DataRecord_namespace
{
	/// <summary>
	/// RIO_DataRecord_Class gives access to the RIO DataRecord
	/// </summary>
	public class RIO_DataRecord
	{
		public uint Header;
		public ushort SampleNumber;
		public byte ErrorCode;
		public byte GenSatus;
		public ushort[] AnOut;
		public ushort[] AnIn;
		public ushort DOut;
		public ushort DIn;
		public uint PulseCount;
		public int ZcData;
		public int ZdData;

		private string zcdata=”";

		const int RIO_RECORD_BYTES = 56;
		const int RIO_ANALOGIO_CHANNELS = 8;
		private Galil.Galil g;
		public RIO_DataRecord(ref Galil.Galil g_passed)
		{
			g=g_passed;
			GetRecord(g);
		}

		public void GetRecord(Galil.Galil g)
		{
			Byte[] b = new Byte[RIO_RECORD_BYTES];
			try
			{
				String s = “”;
				g.write(”QR\r”);
				while (s == “”)
				{
					s = g.read();
				}
				b = ASCIIEncoding.Default.GetBytes(s);
				packRioRecord(b);
			}
			catch
			{
				//throw error
			}
		}

		void packRioRecord(Byte[] b)
		{
			Header = BitConverter.ToUInt32(b, 0);
			SampleNumber = BitConverter.ToUInt16(b, 4);
			ErrorCode = b[6];
			GenSatus = b[7];
			for (int i = 0; i < RIO_ANALOGIO_CHANNELS; i++)
			{
				AnOut[i] = BitConverter.ToUInt16(b, 8 + (2 * i));
			}
			for (int i = 0; i < RIO_ANALOGIO_CHANNELS; i++)
			{
				AnIn[i] = BitConverter.ToUInt16(b, 24 + (2 * i));
			}
			DOut = BitConverter.ToUInt16(b, 40);
			DIn = BitConverter.ToUInt16(b, 42);
			PulseCount = BitConverter.ToUInt32(b, 44);
			ZcData = BitConverter.ToInt32(b, 48);
			ZdData = BitConverter.ToInt32(b, 52);
		}

		public string ZC
		{
			get
			{
				string str=”MG_ZC”;
				zcdata=g.command(str,”\r”,”:”,true);
				return zcdata;
			}
			set
			{
				string str=”ZC”+value;
				g.commandValue(str);
				zcdata=value;
			}
		}

	}
}

We’ll start from the top.  To get the Data Record from the RIO, we first have to create the map for the data that gets returned from the QR command.  The QR command returns a packet of binary data that we will parse to get specific information.  To parse the information, we’ll need to use some of the built in functions of .NET that are contained in the System.Text namespace.

So we first add the System.Text namespace at the top of the code. Next, you will need to add the variable definitions above the “constructor” method after the RIO_DataRecord class definition as shown below.  The size of each variable is taken from Chapter 3 of the RIO User Manual that explains how many bytes are contained in each piece of data.

using System;
using System.Text;

namespace RIO_DataRecord_namespace
{
	/// <summary>
	/// RIO_DataRecord_Class gives access to the RIO DataRecord
	/// </summary>
	public class RIO_DataRecord
	{
		public uint Header;
		public ushort SampleNumber;
		public byte ErrorCode;
		public byte GenSatus;
		public ushort[] AnOut;
		public ushort[] AnIn;
		public ushort DOut;
		public ushort DIn;
		public uint PulseCount;
		public int ZcData;
		public int ZdData;

		private string zcdata=”";

		const int RIO_RECORD_BYTES = 56;
		const int RIO_ANALOGIO_CHANNELS = 8;
		private Galil.Galil g;

Next we can add code to the constructor which as you will recall is what runs when the class is created.  In this case we will need to pass the Galil object that gets created by the main program so that we can use the previously opened connection to send a command and get a response from the controller.  To do this, use the following constructor:

		public RIO_DataRecord(ref Galil.Galil g_passed)
		{
			g=g_passed;
			GetRecord(g);
		}

Now, lets make the GetRecord( ) function that handles sending the QR command and then getting the response.  Note that the .read and .write method of getting the QR info is a very specific case when dealing with the binary response from the controller - in all other cases, the g.command or g.commandValue should be used to send/receive commands to the controller.  Also the while loop is not necessary when using the g.command or g.commandValue and therefore  those functions will speed up communication compared to the .read and .write methods.

		public void GetRecord(Galil.Galil g)
		{
			Byte[] b = new Byte[RIO_RECORD_BYTES];
			try
			{
				String s = “”;
				g.write(”QR\r”);
				while (s == “”)
				{
					s = g.read();
				}
				b = ASCIIEncoding.Default.GetBytes(s);
				packRioRecord(b);
			}
			catch
			{
				//throw error
			}
		}

Notice there is a function that is called packRioRecord(b) inside the above method.  Next, we will create that function so that the Data Record packet that was retrieved can be populated into the correct format.  Here is the function that does this:

		void packRioRecord(Byte[] b)
		{
			Header = BitConverter.ToUInt32(b, 0);
			SampleNumber = BitConverter.ToUInt16(b, 4);
			ErrorCode = b[6];
			GenSatus = b[7];
			for (int i = 0; i < RIO_ANALOGIO_CHANNELS; i++)
			{
				AnOut[i] = BitConverter.ToUInt16(b, 8 + (2 * i));
			}
			for (int i = 0; i < RIO_ANALOGIO_CHANNELS; i++)
			{
				AnIn[i] = BitConverter.ToUInt16(b, 24 + (2 * i));
			}
			DOut = BitConverter.ToUInt16(b, 40);
			DIn = BitConverter.ToUInt16(b, 42);
			PulseCount = BitConverter.ToUInt32(b, 44);
			ZcData = BitConverter.ToInt32(b, 48);
			ZdData = BitConverter.ToInt32(b, 52);
		}

The last thing to do is to show how to create a property instead of a method as shown above.  Properties do not take input parameters - however they can have a value set or a value read.  The code below shows how to create a new property called ZC that will set a value for the ZC value in the data record or will retrieve the value that is currently stored.

                public string ZC
		{
			get
			{
				string str="MG_ZC";
				zcdata=g.command(str,"\r",":",true);
				return zcdata;
			}
			set
			{
				string str="ZC"+value;
				g.commandValue(str);
				zcdata=value;
			}
		}

	}
}

and that finishes the class.  This example shows how to create properties and methods for a custom user class that can extend the capabilities of the GalilTools programming interface.  From here, it is easy to see how one could create a class with custom routines and properties that allow for high level methods and properties.

Save this file and watch for Part 2 of this article which explains how to reference a class inside a C# program.

Quadrature Encoders
Allows use of two encoders
(Channels A+,A-, B+,B-, Index+, Index-)
Part Number: RIO-47122-QUAD

SSI Encoders
Allows use of two (2) SSI encoders
Part Number: RIO-47122-SSI

BiSS Encoders
Allows use of two (2) BiSS encoders
Part Number: RIO-47122-BISS

The new RIO encoder option accepts the position sensor signals at frequencies up to 10 MHz allowing for high speed counting. The Galil command TP (Tell Position) and DP (Define Position) are used to read and define the position, respectively.  The charge for the position input option is $75 in single quantity and $35 in quantities of 100.  Other features of the RIO include analog and digital I/O, Ethernet and RS232 ports, RISC processor for fast I/O handling, PID process control loops, timers, data logging, ability to send email alerts, Power-over-Ethernet, and more.  Custom options are also available.
Please consult Galil at 1-800-377-6329 or see http://www.galilmc.com/products/rio-47xxx.php for more information.
View Other Servotrends Articles

Galil now offers users the option of ordering motion controllers with  on board Coordinate Transformation.  This option allows a user with a complex kinematic transform to have that calculation performed directly on the Galil controller.  Working with a Galil application engineer, the user will review the forward and reverse kinematic transformation for their particular machine.  These equations are then written into the firmware of the Galil controller.  The end result of this process is that the transformation now occurs upon the calculation of each servo update (up to 32kHz), and the user can command the system in machine coordinates rather than simple encoder counts.  In addition, this saves the PC from the burden of performing these sometimes complex calculations.

Benefits

There are many benefits to the Galil implementation of coordinate transformations.  First, with the transformation operating in firmware space rather than user software space, the transformation is able to run quickly and deterministically on each servo update.  There is no latency or variability to the rate of calculation.  Second, as the transformation is handled within the firmware, the user software space is available and unburdened by the overhead of complex transformations.  This allows for faster execution of software routines for other aspects of the application.  Finally, as part of the implementation, Galil will consult with you about your specific application.  This can lead to recommendations which may improve system performance and safety.

Required information

1.  Detailed description of the mechanics to be implemented.  This should include drawings and/or photographs of the specific machine.
2.  Forward and reverse kinematic equations for the specific mechanics.  If these have not already been derived, Galil application engineers will consult with you to derive those equations and make recommendations on the best possible approach.
3.  Detailed description of the application and motions.  This will include typical moves (point to point, constant velocity, high speed step/settle, etc), encoder resolutions, required keep-out zones, expected system bandwidth and any other information related to the motion of the machine.
4.  System boundaries and other range of motion information.  This allows the firmware to work within the usable space of the machine.

Examples

There are many examples of systems which require coordinate transformations for operation, but two of the simplest and most common are the hexapod and the SCARA robot.

1.  Hexapod – A hexapod is a motion platform which has 3 points of contact from 6 individual axes. Imagine 2 linear actuators connected to each corner of a triangle, and you have the basic layout of a hexapod.  A traditional hexapod will give the user 6 degrees of freedom (6dof) in motion, and are commanded with coordinates of Yaw, Pitch, Roll, Heave, Surge and Sway.  The equations of motion for a hexapod could be implemented into the Galil, allowing the user to program the controller in the standard 6dof coordinate system rather than the individual axes (A,B,C,D,E,F,G) format.
2.  SCARA robot – A SCARA robot is a standard positioning robot format which allows positioning of an end effector in the XYplane.  The user is able to command motion to an XY coordinate, with the transformation converting this XY position to the required  mechanics of the robot.  Figure 1 below shows a variation of the SCARA robot.

Figure 1. A coordinate transformation is ideal for this 2-axis SCARA robot

Additional information

Galil has additional detail information regarding coordinate transformations, and how they may be integrated into the Galil motion controllers.  Two white papers have been written which are available on the Galil website.  The links for these pages are as follows:

1.  http://www.galilmc.com/support/appnotes/optima/note3415.pdf

2.  http://www.galilmc.com/support/appnotes/optima/note3416.pdf

The derivative of acceleration is called “jerk” and by ramping up the acceleration - it eliminates the instantaneous change in acceleration.  The result is a rounded velocity profile that can be seen on the overlay of an s-curve and a triangular move profile shown here:

One method of getting an s-curve motion profile is to use the Contour Mode of motion programming which allows the user to define any shape of curve and input it directly into the controller.  In the following example, I’ll show you how to create an S-curve profile using an Excel spreadsheet and then download it to a controller.  To simplify things, we are going to put some constraints on the s-curve profile.  The first constraint is that there will be no “constant speed” portion of the move.  The first half of the move will be the acceleration phase and the second half of the move will be the deceleration phase.  The second constraint is that our move will be made up of 100 contour data segments.

The excel spreadsheet calculates the s-curve profile and uses a Macro to download the data to the controller (GalilTools or GalilTools Lite must be installed in order for the Macro to work).  Open the Excel file and make sure that macro capability is enabled.  Next, put in the desired length of move (positive or negative values are accepted) and put in the desired DT value.  The DT value defines how long the move will take - for more information on how the DT value affects the move, please see the command reference for your controller.  After defining those two parameters - click on the button labeled “Accelera Download” for Accelera series controllers or “Econo Download” for Econo and Optima based controllers.

The Excel worksheet can be modified to extend the number of points, change the axis designation or  change the move profile.

Watch the video on how it works from here (no sound):

http://www.galilmc.com/ftp/pub/appnotes/s-curve/s-curve.avi

Download the Excel file from here:

http://www.galilmc.com/ftp/pub/appnotes/s-curve/s-curve-gt.xls

Alternatively, a s-curve-creator.dmc program can be downloaded and run that dynamically creates the s-curve profile in Galil DMC code.  This can be downloaded from the “Modes of Motion” section of the Sample DMC Code library here:

http://www.galilmc.com/support/sample-dmc-code.php

For information on how to get the standard upgrade option of having an s-curve velocity profile as part of the PA, PR, or JG mode of motion - contact a Galil Applications Engineer.

The typical mechanics configuration for a Laser Control application is a two or three axis stage actuating a laser rail.  The control signal for a laser application is typically a PWM (Pulse Width Modulated) digital signal at a particular frequency and duty cycle (see Figure 1)

Figure 1 A 50% duty cycle PWM with an increasing frequency

Controlling the characteristics of this control signal can affect the operation of the emitted beam in various ways (see Table 1).

Galil can provide precision generation of the laser control signal.  Hardware acceleration and firmware integration provide high performance control that is accessible to the standard motion features of the Galil command set.

Once dynamic modification of laser characteristics is possible, a whole new world of options is opened up allowing for very sophisticated motion control.  The Galil pulse-on-position, also called output compare (See OC in the Command Reference), provides a super-accurate, hardware-based position synchronization for lasing the substrate at an exact position.  A laser imaging application might use PWM and Frequency control in concert with pulse-on-position to form a pixel-based raster image (see Figure 2).

Figure 2 The pixels of the Galil logo have exact horizontal and vertical centers as a result of Galil’s output compare.   The pixel radius is controlled by the PWM duty cycle of the laser control signal when it is pulsed.  The differences of pixel radii provide for the effect of image brightness.

To provide for the fastest possible performance, the stage must be moving at as fast a speed as mechanically possible.  This can be accomplished by providing a hardware-based pixel queue, or FIFO (First In, First Out).  Similar to a raster image processor (RIP) found in laser printers, an image can be transferred into pixels, with the requisite information including physical location of pulse, PWM duty cycle, and even PWM frequency.  This serves as a laser “bitmap” that can be queued and dequeued quickly from hardware to allow for even the fastest motions.

There are many, many more features available in Laser Control Options offered by Galil.  To discuss the options available for you application, including the details above, precise active-window control, vector speed synchronization, and more, contact Galil’s Applications Department today.

Galil motion controllers have standard options for communicating to a number of different absolute encoder technologies. Resolver feedback is a common type of absolute feedback that has been used in motion control systems for a number of years. This can be advantageous in systems where the mechanics are subject to a harsh environment.

An older technology that is still used by some encoders is binary parallel encoders. These feedback devices work by toggling a specific number of bits that represent the absolute position to the motion controller. The draw back to a parallel encoder is that there is a wire for every bit, which can quickly become cumbersome when you look at encoders with 24 bits or more of resolution, especially with a multi-axes control system.

By far the most popular, SSI (Serial Synchronous Interface) feedback is offered by a number of different encoder manufacturers. The advantage to SSI technology is that it is quickly becoming an industry standard due to its ease of use and simple set up. Besides power and ground, there is only a clock and a data signal that need to be connected. Building on SSI, some encoder manufacturers support a BiSS (Bidirectional Serial Synchronous Interface) protocol now. These encoders offer the ability for the encoder to store information locally and transmit them to the motion controller. This builds on SSI which only allows encoder position information to be transmitted.

Another new-comer to the encoder protocol world is the Distance Coded Index. These types of encoders are quasi-absolute. The encoder track is lined with various index pulses that are specific distances apart. Upon power up, with two short moves in either direction, the encoder can read the index pulses and determine the absolute position.

There are many types of encoder protocols to choose from in the current marketplace and Galil motion controllers offer you the flexibility to choose the one that meets the needs of your system.  If you do not see the type of interface you require listed here, call Galil’s applications engineers to review your selected interface.

The SCB-48×06 connects directly to the 26-pin d-sub connector of the RIO-47120 or RIO-47122 and is oriented vertically from the RIO connector. Other mounting options are available on request.

RTD Measurement
An RTD is a Resistive Temperature Device that takes advantage of the fact that a material’s resistance changes as a function of temperature. Most RTD elements consist of a fine coiled wire wrapped around a ceramic or glass core. The RTD element is made from a pure material whose resistance at different temperatures is known. Since the material used has a predictable change in resistance based on temperature – this is used to accurately measure temperature. Typical materials used for RTD’s include: Platinum (most common), Nickel, Copper, Balco, or Tungsten.

Some benefits of RTDs are:
• Wide temperature range
• Good Accuracy (better than Thermocouples)
• Repeatability and resistance to electrical noise
• Long-Term stability (ie: aging)

RTDs are positive temperature coefficient (PTC) sensors which mean their resistance increases with temperature.

Thermocouple Measurement
A thermocouple is based on the “thermoelectric effect” which occurs when two different metals are connected together – a voltage is produced that is dependant on the type of metals used and the temperature. In order for the thermal voltage to produce a current, the metals must be connected together at both ends so that a closed circuit is formed. If the temperature is the same at both ends, there is no flow of current. Thus, a thermocouple can only measure temperature differences. For this reason, the reference junction temperature must be known for an accurate measurement to occur. Since the reference temperature point is generally lower than the measured temperature – it is generally called the cold junction. At the “cold junction” or reference junction, an RTD or similar temperature sensor is used to have an accurate reference temperature. The voltage produced by a thermocouple is very small and amounts to only a few microvolts per degree Celsius. Thermocouples are generally not used in applications in the range of -30 to 50°C because the difference between the reference temperature and the measurement temperature is too small to get accurate noise-free signals. However, compared with other sensors – thermocouples offer an advantage of a higher upper temperature limit and are therefore frequently used to measure temperatures in ovens, furnaces, etc.

Example Applications

Consider an HVAC application where a heating and air conditioning unit needs to be run in order to precisely control the temperature of a room. The block diagram of this setup would look something like this when in the “heating” mode:

In this case a set-point is commanded by an external source and the RIO uses the internal PID filter to close the loop around the 100Ohm RTD. An analog output from the RIO controls the heater such that when the temperature of the room lowers, an error is created between the set-point and the actual temperature measured by the RTD. This error goes through the PID filter and increases the RIO voltage to the heater to raise the temperature of the room. This cycle continues repeatedly to keep the room at the desired set-point.

At $175 in single quantity and $125 in 100 quantities, the SCB-48×06 provides a cost-effective interface to RTDs and thermocouples. Galil’s RIO Pocket PLC series is smart, compact, low cost and packed with I/O. Standard features include analog and digital I/O, Ethernet and RS232 ports, RISC processor for fast I/O handling, PID process control loops, counters, timers, data logging, ability to send email alerts, Power-over-Ethernet, and more. Visit http://www.galilmc.com/products/rio-47xxx.php to download complete specifications and view an on-line video about the RIO.