Re: re:EMC

--- In CAD_CAM_EDM_DRO@egroups.com, Anne Ogborn <anniepoo@n...> wrote:

> Never mind - the LinuxCNC.org site has a sane description of it.
>
> Despite 20 years in the software biz,
>
> "The Enhanced Machine Controller (EMC) program is a NIST effort to

develop and validate

> a specification for interfaces to open architecture controllers."
>
> is still utter nonsense. To parse this -
>
>
> The Enhanced Machine Controller (EMC) program <-- EMC
>
> is a NIST effort <-- that's in English already
>
> to develop and validate a specification for interfaces <-- to

make some software.

>
> to open architecture <-- we're gonna make it public

Ohh, Ohh let me try! A long time ago (in Computer Years) they built
machines (mills, lathes, punch presses) and developed a quasi
standard for the language to control them often referred to as G-
code. Its pretty simplistic and consists of Go commmands that give
an X and Y corroridinates. The X & Y can either be absolute (always
referenced from the 0,0 pint of the machine or incremental (each move
is from the last one) Over the years the code has expanded to cover
specific machine commands to deal with automatic tool changers,
misters, etc. The Control software is responsible to take the G-code
in and do things like issue the correct number of steps and direction
signals to each axis of the machine. 2 axis machine have X (normally
left and right as you stand in front of the machine, and Y, normally
forward and reverse from the same position. The Z axis is normally
an up and down (verticle) axis. There can be others like a rotary
axis and such. If you haven't seen any g-code then you haven't
missed much. The control software has the responsibility to do
things like automatically ramp up and down the motor speeds, monitor
the limit switches to keep things from spinning off onto the floor
and in general move the mechanics of the machine. It can also
provide a closed loop feedback that reads the distance something
moves using an encoder and compare that with what was sent to the
motors to see if it really did do it. The normal stepper system
controller takes the g-command, figures out how many pulses to send
to the motor to get to the next location and assumes the motor did
it. Steppers move in precise increments (most are 1.8 deg of arc per
pulse = 200 pulses per revolution) you then have to do some math the
calculate how far this will actually move your axis given that most
system are moved with course threads of 5 threads per inch.
The "lead" of a screw is the number of times we have to turn it to
make a nut travel one inch. All this math is setup in the controller
and control software. You define how many steps it takes on each
axis to move an inch (or mm). Then the controller knows how many
pulses to send the motor. If you have a servo based system then it
is referred to as a "closed loop system". It most often is not used
with steppers but with DC motors (can be AC in some cases) that are
not limited to a minimum step. The motor has an encoder attached to
it that sends back a pulses as it rotates and we just power the motor
in the direction we want until the number of return pulses are equal
to the number we have defined as the proper pulses per inch. Servo
systems "know" where they are. Stepper systems "assume" where they
are. We could write a book about the advantages of each system.
Obviously the servo is much more complex and expensive to build.
So far we are still in the controller. The controller can be
anything from a "black box" to a PC. There is a generation of
software that runs on a PC and either talks to a special Input/Output
card or through the parallel port. It just sends out simple step and
direction pulses to each motor and can be used to monitor the limit
switches and turn on relays for auxilliary equipment. The output from
a parallel port is not enough to drive a motor so a motor driver
circuit is used to amplify the voltage and current. The size and
complexity of the motor drive circuit is dependent on the size of the
motors. Since motors are basically current devices we slam them with
pulses of higher voltage and let them draw high peak currents.

So far we have just talked about the controller and the motor drive
circuits. If we have our g-code in hand and feed it to the
controller then we should be able to make the machine do whatever we
want. (well, it won't clean up after itself). Entire production runs
of parts have been made using g-code that a coder sat down and wrote
step by step with nothing more fancy than a calculator and editor.

For those of use that no longer get excited about hand coding g-codes
there are other methods. Prior to the post processors of today you
had to take a CAD drawing (or one done by a draftsman) and write your
own code. What somebody finally figured out was that you could take
the raw CAD files that are actually stored as vector math relations
and turn it into g-code...most standard CAD systems will export in a
common file format called DXF (drawing exchange format). What you
want is some that will take the DXF output file from a CAD or
Illustration program and turn it into g-code that the Control
software can turn into machine moves. EMC is a controller software
for controlling the motors and taking feedback from motor encoders
and limit switches. It wants g-code (RS-274).

The rub comes in that not all DXF to g-code translators are good and
very few let you graphically change any of the cut paths they
produce. You have to go back into the g-code and make the changes
manually; which is whole reason you bought a translator to begin with!

Several system combine two or more of these functions in one package
but in most cases you have to deal with seperate software and
hardware packages for each step.

So to summerize: You draw or import a drawing into your CAD or
Illustration software (Autocad, CorelDraw, etc) and export it to a
file of DXF type (or in some cases HPGL). You then run that through
a software process to turn it into g-code (a simple ASCII file) and
then you send that code to the controller (EMC, MasterControlCNC,
DeskNC etc) which then drives the motors that move the
machine....simple huh?

The statement should be: We are trying to build a universal
controller software package that is based on open code, that will run
on just about any kind of computer and that will control just about
anything.