Introducing nanoMoCo, MoCoBus, and the new Motion Engine

nanoMoCo boards and the OpenMoCo Development Framework are now available!  nanoMoCo is a complete single-axis stepper driver/controller that is compatible with the Arduino IDE and development framework.  Want more than one axis? MoCoBus allows real-time synchronization with up to 253 total devices - which can be other nanoMoCo devices, or anything which can speak the MoCoBus protocol.  

nanoMoCo

The nM device is specifically designed to control a stepper and one camera, and has the following features:

• Atmega328P processor running at 16MHz
• 8-16V DC Operation
• Integrated A4983/A4988 bi-polar chopping driver with up to 16x microstepping
• Up to 800 mA/coil without active cooling
• Up to 1.5 A/coil with active cooling
• Dual opto-coupled outputs for safe interaction with other devices
• Integrated RS485 bus for multi-node communication over long distances with only two wires
• Pre-installed bootloader to allow for uploading firmware over RS485 bus
• Compatible with Arduino IDE and AVRDude
• Pre-installed Motion Engine firmware for expressive motion control using MoCoBus
• Leverage the OpenMoCo AVR Libraries and OpenMoCo Qt Libraries to create new software and applications

In addition, there are several I/O lines available, either for MoCoBus, or for your own purposes if using only a single axis.

More details, and how to use the nanoMoCo can be found here: nanoMoCo User Guide.

MoCoBus
To allow for many independent devices to work together, whether they be motor axes or other specialized devices, MoCoBus has been developed. 

MoCoBus uses two integrated buses, one RS-485 bus and one Simple Synchronization Bus, to provide both a command and control channel, and a real-time interaction and synchronization channel.  The command and control channel uses an intelligent and expressive serial protocol to communicate between a master device (a computer, or some other human machine interface) and up to 253 node devices. The simple synchronization channel allows these devices to operate together as needed, without any need for the master device to perform the synchronization between the devices.  This means that power-hungry interfaces can be turned off once the bus has been configured, and the devices will operate completely without any further control required.

OpenMoCo Development Libraries
Implementing the MoCoBus Protocol from scratch is no fun, of course, nor is re-inventing the wheel over and over again to get the exact same end results.  To this end, the OpenMoCo AVR and Qt libraries are now available.  The OpenMoCo AVR Libraries provide everything you need to create a new device to live on MoCoBus, and much of the core capabilities of the new Motion Engine firmware are broken out into re-usable libraries for other projects, including non-blocking intelligent motor control, non-blocking camera control, easy protocol implementation and more. 
Of course, we'd like to make expressive control interfaces as well.  To this end, the OpenMoCo Qt Libraries are provided to allow complete control over a MoCoBus network on Windows, OSX, and Linux. These libraries enable any Qt-based application to easily control hundreds of devices across one or more buses in a multi-threaded, non-blocking manner with ease.  The new Graphical Slim application is built using these libraries and also serves as an example application.

The Motion Engine and Graffik
The Motion Engine is a new firmware for the nanoMoCo boards which replaces the older TimeLapse Engine.  It still offers many of the same capabilities including automatic or manual operation, and complete remote control, but now also has much more expressive motion control capabilities, including multiple easing algorithms, time-to-target moves, and more.  Some of the keys features for the Motion Engine include:

• Complete MoCoBus integration for remote command and control
• Including recognition of all broadcast commands
• Real-time synchronization with other nanoMoCo nodes for autonomous operation
• Asynchronous, non-blocking camera control
• Asynchronous, non-blocking motor control at up to 5,000 steps/second with easing, or 10,000 steps/second without easing
• Numerous types of moves available: from standard continuous;
  defined continuous with arrival time, acceleration/deceleration, and
  distance specified; planned interleaved motion for easy shoot-move-shoot
  operation
• Three types of motion easing algorithms: linear, quadratic, and inverse quadratic
• Automatic (programmed) and interactive operation
• Full control over motor microsteps, disable driver between moves, and more

Graffik is a replacement for Slim with the Motion Engine.  Graffik is a new, Graphical Slim, which has been re-written from the ground up in Qt, and supports OSX and Windows out of the box.  Presently, Graffik primarily provides a script-based interface to nanoMoCo devices, but is being developed to include specialized workflow capabilities for many different kinds of motion control.  




Graffik has the following, basic capabilities:

• Complete scripting language for nanoMoCo devices
• Support for MoCoBus broadcast commands
• Bus scanning and discovery capabilities
• New device initialization
• Save and load script files
• Integrated help
• Saves network configuration between executions