The following example shows how to convert the Galil .dxf file of a DMC-2143, with an AMP-20540 sandwiched on top, to the very common .slw format used by the popular modeling program, SolidWorks.

1) The first step is to obtain the .DXF solid from Galil.

2) The next step is to open the file through Solidworks.

You will be prompted by a screen seen below, giving you many options as to how to import the file.  To import Galil-generated files, select the option to import as a new part.  Select the radio button next to "Import a new part" and click next.

3) The next screen to appear will be the following.  This allows you to import selected layers as a 2-D drawing, or to import the file as a 3-D model.  Select the tab that is labeled "Model" (located under the preview window).  This should automatically check the "Import sheet as" check box and fill in the text box next to the check box with "Model."  This indicates to the program that you wish to import the file as a solid, 3-D model and not a 2-D drawing.  Click next.

4) The final screen can be seen below.  To import the file as a 3-D solid and not a 2-D sketch, select the radio button labeled "as 3D curves/model."  This should automatically populate the check box next to the radio button labeled "Import this sheet:."  The option to change import dimensions is also given in the upper left corner drop down menu.

5) After selecting 3-D model click on "Finish."  Solidworks will automatically render the part as a 3-D solid within design space.  This can be imported into an assembly or other modeling documents.  Solidworks also allows you to save the model as many other different CAD formats in case another is desired.

Here’s what the script does:

1.) Saves a copy of the current network configuration to a file
2.) Sets “Local Area Connection” to static, 192.168.1.1, with a subnet of 255.255.255.0
3.) Launches GalilTools
4.) Once GalilTools process ends, it restores the network connections saved in 1

@Echo Off
Color F0
title LEAVE OPEN to restore network after GalilTools

REM create a file for the backup.  Use a random number suffix for semi-unique filename
Set GalilFile= GalilNet%random%.txt
CLS

Echo *** Backing Up Current Network Settings to %GalilFile% ***
Echo Current Settings:

REM display network data to screen and backup to dump file (for debugging)
ipconfig
Echo %date% %time% >> ipconfigDump.txt
ipconfig >> ipconfigDump.txt

REM dump current network config to backupfile
netsh -c interface dump > %GalilFile%
REM create a restore batch file in case this script is exited before restoration. Just run this batch and the old settings will restore
ECHO netsh -f %GalilFile% > RELOAD-LAST.bat

Echo.
Echo *** Preparing Network Connection for GalilTools ***
REM setup for Galil Controller
netsh interface ip set address name="Local Area Connection" source=static addr=192.168.1.1 mask=255.255.255.0
Echo.
Echo *** Network changed ***
Echo New Settings:

REM display network data to screen again
ipconfig

REM launch GalilTools
Echo *** Launching GalilTools ***
"c:\program files\galil\galiltools-x86\bin\galiltools"

REM when the GalilTools process exits, the old settings will be reset
Echo *** Loading Settings from %GalilFile% ***
Netsh -f %GalilFile%
Echo Current Settings:
ipconfig

REM leave the config file, but delete the restore batch file
REM del %GalilFile%
del RELOAD-LAST.bat

1.) asynchronous dumps of controller data, arrays, variables, etc. Backup of controller EEPROM to central server.

2.) Controller “pushing” events to pc, perhaps allowing the PC to invoke email, SMS, or other higher-level functions.

3.) Fully DMC-code-centric application design for Galil language fans.

The below code as a minimal VB example of how to create a PC server.

‘minimal code to sart listening to a port on the host.  Allows the Galil Controller to be the master (client) over the PC (slave/server)
‘IHB=>-2
‘WT100
‘IHB=192,168,1,10<13000>2
‘WT100
‘CFB
‘CW2
‘c=0
‘#LOOP
‘MGTIME
‘WT1000
‘c=c+1
‘JP#LOOP,c<10
‘IHB=>-2
‘EN

Imports System
Imports System.IO
Imports System.Net
Imports System.Net.Sockets
Imports System.Text
Imports Microsoft.VisualBasic

Module Module1
    Sub Main()

        Dim server As TcpListener
        server = Nothing
        Try
            ‘ Set the TcpListener on port 13000.
            Dim port As Int32 = 13000
            Dim localAddr As IPAddress = IPAddress.Parse(”192.168.1.10″) ‘address of host’s nic card (where to listen locally)
            server = New TcpListener(localAddr, port)

            ‘ Start listening for client requests.
            server.Start()

            ‘ Buffer for reading data
            Dim bytes(1024) As Byte
            Dim data As String = Nothing

            ‘ Enter the listening loop.
            While True
                Console.Write(”Waiting for a connection… “)

                ‘ Perform a blocking call to accept requests.
                ‘ You could also user server.AcceptSocket() here.
                Dim client As TcpClient = server.AcceptTcpClient()
                Console.Write(”Connected to ” + client.Client.RemoteEndPoint.ToString + ” “)

                data = Nothing

                ‘ Get a stream object for reading and writing
                Dim stream As NetworkStream = client.GetStream()

                Dim msg As Byte() = System.Text.Encoding.ASCII.GetBytes(Chr(18) + Chr(22) + vbCrLf) ’send control R control V to display controller type
                stream.Write(msg, 0, msg.Length)

                Dim i As Int32

                ‘ Loop to receive all the data sent by the client.
                i = stream.Read(bytes, 0, bytes.Length)
                While (i <> 0)
                    ‘ Translate data bytes to a ASCII string.
                    data = System.Text.Encoding.ASCII.GetString(bytes, 0, i)
                    Console.Write(data)
                    i = stream.Read(bytes, 0, bytes.Length)
                End While

                ‘ Shutdown and end connection
                client.Close()
            End While
        Catch e As SocketException
            Console.WriteLine(”SocketException: {0}”, e)
        Finally
            server.Stop()
        End Try

        Console.WriteLine(ControlChars.Cr + “Hit enter to continue….”)
        Console.Read()
    End Sub ‘Main

End Module

Think& Do is a software package offered by Entivity that allows a standard computer to act as a PLC for remote IO units. This type of software is often referred to as a "soft PLC". One of the key advantages of the Think & Do software suite is it’s implementation of numerous communication protocols, including Modbus TCP/IP.  Modbus TCP/IP is one of the only truly open communication protocols in the automation industry and is supported by a majority of automation devices including PLC’s, HMI’s, sensors and much more.

In order to take advantage of every feature that the Think & Do software provides, along with numerous other Modbus TCP/IP devices, Galil has recently added to the RIO’s Modbus feature set. These features include:

1) Supporting Modbus function code 15 as a slave

2) Swap how function codes 3 and 4 work(MV command)

3) Set data transfers as 16 bit integers as opposed to 32-bit floating point values(MI command)

Function Code 15

In RIO firmware version 1.0a function code 15 is only supported as a Modbus master. In version 1.0b(the standard version which now ships), Galil has added support for function code 15 as a Modbus slave. This allows other devices to set multiple digital outputs on the Galil at the same time

MV Command

The RIO will default to answering function code 3 requests with analog input data and function code 4 requests with analog output data. By setting MV1 the RIO will then respond to function code 3 requests with analog output data and function code 4 requests with analog input data.

MI Command

By default the RIO will conduct data transactions for function codes 3,4 and 16 as 32-bit floating point values . By setting MI1, the RIO will then use 16-bit integers instead.

For more details on all of these features please refer to the RIO user manual and command reference or talk to an Applications Engineer at Galil. 1-800-377-6329

Whether it’s analog inputs, analog outputs, digital inputs or digital outputs that you’re after – Galil’s RIO Pocket PLC has it all and then some. Each RIO is loaded with I/O including 8 analog inputs, 8 analog outputs, 16 digital inputs and 16 digital outputs. Use them stand-alone or network multiple RIOs to handle all the I/O in your machine.

2. Smart
Combined with the I/O capability is a fast 32-bit microprocessor with a built-in 100BaseT Ethernet and 115k baud RS-232 serial port. If you need non-volatile memory and programmable logic, it’s in there. You can program the RIO with either Galil’s intuitive two letter command language or you have the option of using Galil’s Ladder Logic Interface software. Download your program, burn it in, and walk away.

3. Compact
The beauty of the RIO Pocket PLC is that its small size does not take away from its exhaustive capabilities. The RIO measures just 3.88” x 4.26” x 1.30”.

4. Low Price
Galil understands that budgets are tight so why not free up some of that budget – at a price of $295 in single quantity or $195 in 100 qty for the RIO-47100– that should give you some wiggle room.

5. Process Control Loops & Pulse Counter
No problem. The RIO has two independent process control loops. Just set up your analog input and output range, adjust the PID filter values, and you’ve got Galil’s powerful control algorithm doing all the dirty work for you. However, if that’s not enough, then maybe you’re in need of a pulse counter. The RIO has it covered – just enable it and you can count on either high or low going pulses. Tying the Pocket PLC to your machine just got easier.

6. Modbus/TCP Master and Slave
Still not enough? If it’s because you need Modbus/TCP– well, here’s some good news – the RIO can be a Modbus Master or Slave. Just put it on the Ethernet network and start using your Modbus Enabled devices to control the I/O remotely. Now you can easily interface to HMIs, PCs, motion controllers and other I/O devices.

7. Data Logging
But does it have data-logging? Yep. A snapshot of the controller’s I/O is recorded internally every other sample – just hook up via Ethernet to get real-time data displayed and stored on your Windows or Linux computer.

8. Web Interface and Email Capability
It doesn’t stop there though, with a web interface and email capability – you can set up event conditions to alert you via email or even send an email to a cell phone. You set up the conditions and the RIO monitors the machine…Automation at its best.

9. Use Screw Terminals or D-Subs
Screw Terminals vs D-Subs? It’s the age old question of convenience versus reliability. Well, now you don’t have to choose just one. The RIO provides D-sub connectors for cost-effective, reliable connectivity. Or, use mating ICS boards which provide screw-terminals for convenient prototyping and quick connections to I/O points.

10. Customization
And to top it off, if the RIO Pocket PLC doesn’t have it…Galil will put it in. Galil prides itself in being flexible to customer’s needs and has a very successful track record of creating custom solutions to achieve success. This ranges from simple firmware modifications to full-blown custom hardware.

Check out Galil’s new RIO Pocket PLC today
Download complete specifications at www.galilmc.com/pocketplc. Contact a Galil Applications Engineer today to discuss your application at 1-800-377-6329.

Pocket PLC Price Comparison by Part Number

	RIO-47100	RIO-47120	RIO-47120-16
16 Digital Inputs (5-24VDC)_________________	yes	yes	yes
8 High Power Digital Outputs (12-24VDC @ 0.5A each)_________________	yes	yes	yes
8 Low Power Digital Outputs (5-24VDC @25mA)_________________	yes	yes	yes
8 Analog Inputs_________________	0-5V (12bit Res)	0-5V 0-10V +/-10V (12bit Res)	0-5V 0-10V +/-10V (16bit Res)
8 Analog Outputs_________________	0-5V (12bit Res)	0-5V 0-10V +/-10V (12bit Res)	0-5V 0-10V +/-10V (16bit Res)
	$295 (qty1) $195 (qty100)	$345 (qty1) $245 (qty100)	$395 (qty1) $295 (qty100)

]]> http://www.galilinmotion.com/techtalk/io-control/top-10-reasons-to-choose-galil%e2%80%99s-rio-pocket-plc/feed http://www.galilinmotion.com/techtalk/software/using-excel-for-data-logging-with-an-rio-pocket-plc http://www.galilinmotion.com/techtalk/software/using-excel-for-data-logging-with-an-rio-pocket-plc#comments Wed, 16 Jul 2008 21:50:37 +0000 John Hayes http://www.galilinmotion.com/techtalk/?p=23 In this article, we’ll explore how to use Microsoft Excel for data-logging using the RIO Pocket PLC and an Ethernet connection. I’ll explain the steps necessary to get from a blank spreadsheet to a useful data logging application in about 15 minutes.

There are a few things needed for this to work. The first thing is a RIO-471×0 (although any DMC motion controller with Ethernet capability will also work) and the second thing is to install GalilTools($195) or GalilTools-Lite (free).

After installing GalilTools software, you should assign an IP address to the RIO. In this example, I’m using 10.0.6.47 but you should assign an IP address that is compliant with your network settings. After assigning an IP address – connect up to the controller in GalilTools to verify that communication is working.

Part 1: A Simple Application

We’ll start with a simple example of sending a command to query the built in “TIME” variable on the controller. This variable is constantly updated inside the controller to reflect a running time in milliseconds. To get this value, we need to send down the string “MG TIME” and that tells the controller to return the value of TIME.

To do this, turn on the View -> Toolbars ->“Control Toolbox”

and make sure you are in “Design Mode” by enabling the icon on the far left.

Next, add a button to your Excel spreadsheet by clicking on the button icon and dragging it on to your spreadsheet. Right Click on the button and choose Properties. Modify the Properties to name the button and give it a caption.

Your sheet should look something like this:

Now, double click on the button and the Visual Basic Editor window will pop up. Go to Tools-References and enable the checkbox for “Galil” as shown below.

If there is no Galil checkbox, click “Browse” and choose the file C:\Program Files\Galil\GalilTools-x86\lib\IGalil.tlb. Click OK.

Now add the following text to your Button Click Function:

Private Sub GetTIME_Click()
Dim g As New Galil.Galil
g.Address = "10.0.6.47" 'Connect to IP address of RIO Pocket PLC
Sheet1.Cells(4, 4) = g.Command("MG TIME") 'Send Command MG TIME
End Sub

But replace the IP address with the IP address of your RIO unit. Go back to Sheet1 and click the icon on the Control Toolbox to “Exit Design Mode”. Now click on the button and you should get a value in cell D4 like this:

You can build an entire application from the simple steps shown above to achieve an interactive user interface to the RIO. This simple example allows you to send commands and receive responses via an Excel spreadsheet. However, for a data logging application – this just isn’t going to cut it so Part 2 of this article is going to look at some more advanced features such as accessing the internal Data Record of the controller. So go grab a cup of coffee because you’ll want to be awake for the next part.

Part 2: Using the Data Record

Now that we’ve gotten the Excel spreadsheet communicating to the controller, its time to grab some data! Create a new Excel workbook and follow the same steps as Part1 to add a button named GetDataRecord and include the Reference to IGalil.tlb. For all Galil controllers, there is a “snapshot” of all the internal values that can be sent out at a regular interval. This snapshot is called the DataRecord and you can see exactly what values are stored by looking at Chapter 3 in the User Manual of the controller. The code below runs a loop that grabs all the values from the DataRecord and stores them into successive rows of the Excel spreadsheet.

In your Code View window, add the following code:

Private Declare Sub Sleep Lib "kernel32" (ByVal dwMilliseconds As Long)

Private Sub GetDataRecord_Click()
Sheet1.Range("A1:BH100").Clear 'clear spreadsheet

'Make sure to add the Reference to IGalil.tlb under Tools - Add Reference
'Security level in Excel should be set to Medium to allow macros

Dim g As New Galil.Galil
g.Address = "10.0.6.47" 'Connect to IP address of RIO Pocket PLC
Dim i As Integer
i = 1
For j = 0 To 60 'For loop to list sources and the units
Sheet1.Cells(1, j + 1) = g.sources(j)
Sheet1.Cells(2, j + 1) = g.sourceUnits(g.sources(j))
Next j
j = 0
Dim DataRecord As Variant
'Data starts at row 3 and we are collecting 25 samples
For i = 3 To 50
DataRecord = g.record
For j = 0 To 60 'gets each datapoint
Sheet1.Cells(i, j + 1) = g.sourceValue(DataRecord, g.sources(j))
Next j
DoEvents 'allows user to do other things during loop
Sleep (25) 'sleep for 25 msec
Next i
End Sub

The first statement just declares a Sleep function. The GetDataRecord_Click() subroutine is what runs the code to grab the RIO datarecord and display it to the screen. Adjust the values of the For loop to the desired number of samples and the Sleep timer can adjust the desired sample rate.

Clicking on the Button should fill up Sheet1 with data like this:

The next step is to take advantage of the many chart & report functions of Excel that display the data in a format that’s easier to read. Here’s an example of graphing the analog output while it is performing a sine wave.  The dmc code used to generate the sine wave on the analog output is located under the I/O section of the sample code library here: http://www.galilmc.com/support/sample_code.html

(Click to see video)

As a last step, for Excel to allow the VB code to run, the Macro Security level needs to be set to “Medium”. To do this, go to Tools -> Macro -> Security…. and then click on the “Medium” level as shown here:

Although using Microsoft Excel does have its limitations, the big benefit of using this method to build a data-logging application is that it is quick and easy and allows the user to be generating graphs from their I/O in just a few minutes.

]]> http://www.galilinmotion.com/techtalk/software/using-excel-for-data-logging-with-an-rio-pocket-plc/feed http://www.galilinmotion.com/techtalk/drives/simple-method-for-mirroring-byte-streams-from-rs232-to-ethernet http://www.galilinmotion.com/techtalk/drives/simple-method-for-mirroring-byte-streams-from-rs232-to-ethernet#comments Thu, 03 Jul 2008 22:44:40 +0000 Galil_DJR http://www.galilinmotion.com/techtalk/?p=21 If you have a device that talks serially to a Galil Serial port, this code will mirror the incoming byte stream to an outgoing Ethernet Handle.

Lower baud rates may be necessary depending on the volume of data being transmitted.

CI2,1;'configure communication interrupts for DMC-21x3
CFB;'send unsolicited messages out of the B handle -- ensure that this is an
'unconnected handle or a unimportant one. Messages (error codes) sent here
'should be ignored
'
CW1;'CW2 for non-Galil receiving software, CW1 for Galil, example, g.message()
'
#LOOP;'dummy loop running, #COMINT interrupts here
JP#LOOP
'
'
REM when character comes in on RS232 port
#COMINT
MGP1CH{S1}{N}{EA}
REM Note the {EA}. This sends the character to the desired handle.
REM Every 80 characters without a carriage return will generate a ?
REM from the controller. Due to the CFB above, this is ignored.
REM The ? is generated because 80 characters is the standard command
REM line max. It doesn't matter here with serial port in CI mode.
REM Note, Carriage returns are not mirrored, so use a different delimeter
REM
REM to optimize packet traffic, concatenate chars (in array)
REM and send periodically in one MG
EN1,1 ;'return from COMINT

For complete details, go to Application Note #2511 located here:

http://www.galilmc.com/support/appnotes/accelera/note2511.pdf

]]> http://www.galilinmotion.com/techtalk/motion-controllers/ics-48100/feed http://www.galilinmotion.com/techtalk/dmc-programming/automatic-subroutines-with-accelera-controllers http://www.galilinmotion.com/techtalk/dmc-programming/automatic-subroutines-with-accelera-controllers#comments Mon, 16 Jun 2008 16:18:49 +0000 Galil_AndyH http://www.test.galilinmotion.com/techtalk/?p=15 Many new features were added to the Accelera product line that were not available in prior generation Galil controllers. One of these more overlooked features is the fact that some Automatic subroutines no longer require thread 0 to be running on the controller for the routine to run. This is extremely useful as a safety feature for the #AMPERR, #LIMSWI and #POSERR routines, a helpful diagnostic tool for #TCPERR, and it gives the programmer much more flexibility when using the #ININT routine.

Because prior generation controllers required thread 0 to be running in order for those routines to execute, the routines could be easily written using arrays, variables or other settings that could be initialized in something like a #AUTO program, or a the beginning of a program that is executed from a host. With Accelera controllers, the programmer can no longer rely on the program running on the controller to initialize variables or settings, because the automatic routine has the ability to run before that program is even executed.

When programming Automatic subroutines on Accelera controllers, the programmer should not depend on variables or settings that are either not defaults on the controller, or are not burned into non-volatile flash. The automatic routines should also remain in the routine until the error or reason for the routine execution is cleared.

Here is an example of a #AMPERR routine that will cause problems, and another that should run without problems


REM Incorrect #AMPERR routine
#AMPERR
IF initvar=1
MG"Run Init Routine"
ELSE
ENDIF
RE


If an Amplifier Error occurs while there is no program running on the controller and the above code is in program memory, there are potentially 2 issues that could arise with the above code. If the variable “initvar” is not defined in controller memory, an error will occur and the routine will end. If there is no #CMDERR routine in program memory, #AMPERR will then automatically start again because there is still an amplifier error. This is essentially an infinite loop. If “initvar” is defined, the #AMPERR routine is a very short routine that does not address that actual amplifier error before it exits the routine. Once the routine ends, #AMPERR will start right back up - another infinite loop.

Here is a #AMPERR routine that will allow the controller to deal with the amplifier error, or at least properly notify the user/host of the state of an amplifier error. (This code is written for a DMC-40×0 controller) The routine uses no variables that are not defined in the actual #AMPERR routine, and it also checks to see if the amplifier error has cleared and only exits the routine under a cleared condition.

#AMPERR
REM mask out axes that are in brushed mode for _TA1
mask=(_BRH*128)+(_BRG*64)+(_BRF*32)+(_BRE*16)+(_BRD*8)+(_BRC*4)+(_BRB*2)+_BRA
mask=@COM[mask]
mask=((_TA1&mask)&$0000FFFF)
LU0;’turn off auto update of LCD
REM amplifier error status on LCD
MG”A-ER TA0″{L1},_TA0{L2};WT2000
MG”A-ER TA1″{L1},mask{L2};WT2000
MG”A-ER TA2″{L1},_TA2{L2};WT2000
MG”A-ER TA3″{L1},_TA3{L2};WT2000
LU1;’turn on Automatic Axis Update of LCD
WT5000
REM the sum of the amperr bits should be 0 with no amplifier error
er=_TA0+mask+_TA2+_TA3
JP#AMPERR,er0
REM Notify user amperr has cleared
LU0
MG”AMPERR”{L1},”RESOLVED”{L2}
WT3000
LU1
RE


To account for this, the Galil controllers allow the user to change the DC value within the LIMSWI routine. Here, you can set the DC value very high, in order to stop well before coming into contact with the hard stop. The following figure shows a profile with the DC value left low. The time to stop is quite long, and the distance traveled is too far into the hard stop.

The following screen shot show the result of changing the DC value when running the #LIMSWI routine. The time to stop has been dramatically reduced.

Here is a sample DMC program that performs this change.

#LIMSPD
NOTE EXAMPLE OF CHANGING DECEL IF A LIMIT OCCURS
ACX=1024
DCX=1024
SPX=4096
PRX=100000
BGX
#LOOP
JP#LOOP
#LIMSWI
DCX=1024000
STX
AMX
MG”LIMIT”
EN