LEonard is a hard-core factory automation conductor running in C# on Windows 11. LEonard has been deployed successfully in general robotics, 3D part finishing, 3D robot guidance, and 3D inspection applications, with more applications to come.

Designed by robotics and machine vision experts and built for reliability, factory floor durability, and easy customization, LEonard is the product of nearly 40 years of factory automation experience. It is the conductor that can seamlessly glue together the best factory automation components in the industry, including hardware from major robot manufacturers, major machine vision providers, PLC companies, sensor companies, and more. If it talks SIPC, MODBUS, Ethernet IP, Profi, sockets, RS-232... we can interface to it and give you a conductor: a programming environment (now in LEscript, Java, or Python!)  to monitor and sequence your whole industrial work cell.

Contact us to talk about your application if:

Lecky Engineering also does hard-core custom robot programming, machine vision algorithm development, and integration of ML and Deep Learning techniques, and can build these customizations into LEonard to make them easy for you to understand, set up, and reuse.

What is LEonard All About?

Well, the manual says it best! But here is the high-level overview:


LEonard is a work cell control program that maintains communication with all the devices in your industrial work cell and allows you to orchestrate their coordinated operation using simple scripting- just like a good orchestra conductor.


LEonard allows you to write work cell control Sequences in LEScript, Java, or Python. You can also use Java and Python to create complex programs and subroutines that the LEonard Sequence calls, so LEonard doesn’t trap you in someone else’s framework. The use of Java and Python opens the potential to use millions of lines of pre-existing code, as well as providing you with all the features of these rich programming environments.


LEonard is designed to talk to a variety of devices and allow you to coordinate all of them through a single script. LEonard’s tested and validated devices include:



o   Universal Robots

o   Fanuc

o   ABB

o   Kawasaki

Vision Systems

o   LMI Gocator


o   Teledyne Sherlock

o   Cognex Insight

ID Readers

o   Keyence

o   Cognex Dataman

o   Zebra FS40

PLC Interfaces

o   SIPC


External Devices

o   TCP Connections

o   Serial Data


Really, anything you can talk to with Java or Python is a candidate for adding in yourself! Lecky Engineering adds custom device interfaces at customer request. These are usually very simple code extensions to develop, often identical to or very similar to something we already have.


Why does it look like this?

LEonard is industrial control software and is designed to work well on standard 10” industrial touch screen tablets. Buttons are large and easy to read and special file open and save dialogs, as well as numeric entry, are handled in a touchscreen-friendly way.

 LEonard can also be used comfortably on larger monitors. The screen, all the dialogs, and even the font sizes automatically scale as you use different screen sizes or resize the application window.

 LEonard provides a standard database of various fixed screen sizes and behaviors, and you can add your own.


LEonard talks to all of your devices in the work cell. These can be software programs like a vision system, or physical devices like a robot, a sensor, or an external server.

Each device has extensive setup and configuration capability.

LEonard supports TCP, Serial, and many specialty protocols with more coming all the time.

LEonardStatements and LEonardMessages

The LEonard "general" CallBack knows how to interpret what it receives, whenever it receives it. This means that external devices can send messages to LEonard whenever they want.

The received messages need to be what is called a LEonardMessage… a series of LEonardStatements separated by some separation character.

When a LEonardStatement is analyzed, it is expected to be any one of the following. These are checked in sequence and the first match is handled and the other options untested.

1) filename.js Execute an entire Java file (wow!)

2) filename.py Execute an entire Python file (wow!)

3) LE:script Execute any LEScript statement

4) JE:script Execute any Java statement

5) PE:script Execute any Python statement

6) SET var_name value Set var_name = value all languages

7) GET var_name. Return the current value of variable var_name

8) var_name = value  Stores value into var_name for all languages

Any device can basically and very simply ask LEonard to do whatever you want at any time. I wouldn't want this on an open network, but industrial work cells have private, controlled networks and all of the devices in the work cell must be trusted.

Are you worried that your PLC might send a move command to the robot that would make it hit the wall? That's called software debug in a work cell and those things must be fixed by the programmers in advance. LEonard lets you orchestrate known-working robot and vision programs and have a simple user interface on top of them.

So this makes a ton of sense in this factory automation applications!

Sequence Programming

You can build subroutines and subprograms in Java or Python, but some sort of master control sequence needs to be built to control the work cell. This is the LEonard Sequence.

LEonard orchestrates the interoperation of many devices using a Sequence, a simple program script that can be written in LEScript, Java, Python, or a combination of all three.

All three languages are provided to make things easier for you. Use what you like.

LEonard executes the main Sequence one line at a time. This permits monitoring, error recovery, and single stepping.

This may seem odd to those with a formal Computer Science background. I have one, but it is tempered with a BS in Mechnical engineering and a PhD in Electrical Engineering. I do teach Computer Science classes at SUNY Plattsburgh for fun, however.

But what's this line-by-line?

For reasons of safety and error-recovery, each line of a work cell Sequence needs to be handled all on its own.

This also allows single stepping through work cell operations, critical during debug and testing.

LEonard line execution rate is slow, perhaps 10 lines per second. But work cell lines are asking robots and vision systems to do things that typically take many seconds so this doesn’t matter.

Wait! What if I want to read the same barcode reader 10 times and return the highest confidence reading?

Just do it in Java or Python. Those languages run at full speed, you can build a function, and since it doesn't block for very long, you can safely just call it from your Sequence.