Grblshield vs. TinyG

Hi.

Grblshield is a 3 axis stepper controller that runs the motors for the grbl softeare. Grbl runs on an arduino. Lookup github/grbl/grbl.
TinyG is a standlone motion controller that runs 4 axes. The specifications are different. See http://www.synthetos.com/wiki/index.php?title=Projects:TinyG

Both provide up to 2.5 amps per phase. Your motors should work but you should use heatsinks and fan cooling.

Lead time is typically about 1 week or less.

We ship USPS international.

It is a good question, and one that should have a good answer. So please bear with this lengthy post. I’m not going to argue about which is “better” – we are heavily involved in both projects and want them both to be successful.

Basic similarities between grbl+grblshield and tinyg:
* Both basically support the same set of Gcodes – with some minor differences. refs:
https://github.com/grbl/grbl/wiki
http://www.synthetos.com/wiki/index.php?title=Projects:TinyG-Gcode-Support
* Both adhere as closely as possible to the NIST Gcode spec. refs:
http://www.isd.mel.nist.gov/documents/kramer/RS274NGC_3.ps
http://technisoftdirect.com/catalog/download/RS274NGC_3.pdf
* Both implement enhanced CNC features such as homing cycles, feedhold (!) and restart (~ , aka cycle start) and software reset (control-x)
* Both use Texas Instruments DRV8811 stepper controller chips
* Both are written in C, GNU GPL open source licensed
* Both projects are currently in beta

Some fundamental differences are:

* grbl is an XYZ 3 axis controller (i.e. a cartesian robot). TinyG is a 6 axis controller that runs XYZ and also ABC rotational axes. Many of the difference are attributable to this fact. See the NIST spec (above) as to how rotary axes work, or refer to the discussion on the TinyG wiki on rotational axes:
http://www.synthetos.com/wiki/index.php?title=TinyG:Configuring#Rotational_Axis_Settings_and_Modes

* TinyG has 4 motors, grblshield has 3. What’s up? It is possible (and common) for grbl to run dual gantry configs – like a dual Y by using 2 stepper drivers attached to the Y step and dir lines. This can present some challenges in homing, but in general this works pretty well. Grblshield only supports 3 axes, and the motors are tied to the X, Y and Z axes. In TinyG the motors are configurable (mappable) to an axis. If you want 4 X axes, map motors 1-4 to X and have a great day. Generally people map the 4th motor to Y the or A axis.

* TinyG runs 3rd order, constant jerk acceleration profiles, grbl runs 2nd order constant acceleration profiles. What does this mean? In grbl the velocity profile during acceleration and deceleration looks like a pure trapezoid in time. For example the move starts at zero velocity, then velocity ramps in a straight line to the target velocity, then decelerates in a straight line back to zero. In TinyG the velocity profile is an S curve that ramps to the target velocity during acceleration and in reverse during the deceleration phase. The means that you can run to motors harder in transition and hence operate at faster accelerations and decelerations. See:
http://www.youtube.com/watch?v=pCC1GXnYfFI

It also means there are fewer machine resonances excited (that cause chatter and other problems) as the jerk term is controlled. Jerk is a measure of the impact a machine is hit with during a velocity change.

* All settings on TinyG are configurable on a per axis or per motor basis. In grbl one parameter applies to all axes (XYZ) – with the exception of steps per mm and polarity – which must be settable on a per axis/per motor basis. A subtlety is that TinyG treats axes and motors as different objects that are configured independently and them mapped together. grbl treats them as the same object – which is fine given its XYZ mission. TinyG does not have that luxury as it needs to support ABC axes which need very different configurations that X Y and Z (to start with, they are in degrees, not linear units…).

Independent control also becomes an issue if the dynamics of the Z axis are significantly different than X and Y, like on Shapeoko where Z is a screw axis and X and Y are belts.
refs:
https://github.com/grbl/grbl/wiki/Configuring-Grbl
http://www.synthetos.com/wiki/index.php?title=TinyG:Configuring

* TinyG is designed to be run “from the command line”. Since there are more configuration settings to worry about it offers a set of mnemonics for configuration, machine state and configuration status inquiries. It also offers real-time status reports (DRO-type output). grbl also has real-time status reports in edge right now. TinyG has a set of help screens available from the command prompt. grbl offers some of these features but in general is more “silent”. There are plans to add new features to grbl in future releases, and we are participants and boosters in those discussions.
refs:
https://github.com/grbl/grbl/wiki
http://www.synthetos.com/wiki/index.php?title=Using_TinyG

* In addition to command line operation, TinyG implements a JSON interface. This gets pretty arcane, but is useful if you are writing a controller for TinyG. The JSON interface is really a REST interface that implements the objects and verbs in the system. Its different from what people normally think of as REST in that the transport is USB serial, not HTTP.
http://www.synthetos.com/wiki/index.php?title=Projects:TinyG-JSON

* TinyG implements a set of embedded self tests to verify proper system operation and assist in setup

* Different embedded processors:

– The processor chip for grbl is an Atmel ATmega328p that runs on the Arduino *hardware*. Note that once you program grbl onto it it is no longer an “Arduino” as you have taken over the chip and it it will not run Processing anymore (until you re-flash it – then it’s no longer grbl) The 328p runs at 16 Mhz, has 32K FLASH memory (program memory) and 2K of RAM
ref: http://www.atmel.com/Images/doc8161.pdf).

– The processor chip on tinyg is an Atmel Xmega192A3 that runs at 32 Mhz, has 192K FLASH and 16K RAM.
ref: http://www.atmel.com/Images/doc8068.pdf)

The difference in processors means that tinyg can do more computation and have larger firmware and RAM usage. It also means that grbl is programmable using a garden variety Atmel ISP programmer, and TinyG requires a programmer that implements the newer PDI programming protocol – such as the Atmel ISP MKII programmer (at $35 from Mouser electronics. This programmer also works fine on the older protocols). We implemented a boot loader on tinyg at one point (xboot project) but found AVRdude to be so unreliable that we did not release it. We also offer a firmware upgrade service for the cost of postage back and forth, but really if you are interested in keeping up with the project you should get a capable programmer.

The processor difference also means that grbl generates step pulses at a rate of 30Khz, TinyG at 50Khz.

There are a number of other differences such as communications and various system, settings, but this really gets lost in the weeds. Refer to the respective wikis – particularly around configuration if you feel the need to chase this down.

Hopefully that answers some of the questions.

– Alden

I am intending to put this on the wiki, as the question has come up more than once. A few pictures would also help. I wanted to get this to you so I figured it could originate in the forum.

As for your project, I think either solution would work, and the grbl solution is less expensive. The acceleration difference come into the picture when you really try to push the speed envelope, which it sounds like you don’t need to do. The adaptation of the Z axis also sounds manageable if you are willing to pre-process your G code. Just set the Z travel to some known value and emit code that gets the right amount of rotation.

Alden

Hello.
For what it’s worth, I decided to go with TinyG in the end (I realized that many sewing machines have a dial for thread tension and I might be willing to adjust it with a stepper for wide stitches at a later time; hence the need for a 4th axis)

Fabrice