Nick Mudge Ignition Software Consulting & Development

I am starting a new Ignition project called Perfect Project Manager. This will be an application that is used to help manage the development of projects. It is a project management tool.

This is an open source project using the MIT license. People and companies will be free to use and modify the project for their own uses including commercial uses. People and companies will also be free to join the development and contribute new things to the project.

Why Am I Doing This?

Perfect Abstractions needs a better project management tool. And I need a better way to train new Ignition developers. And I would like to be involved in an open Ignition community development effort. Here are the goals of the project:

  1. An Ignition project that is a project management tool for managing the development of projects. People and companies use it because it is useful.
  2. An on-going collaboration and community-based development of Perfect Project Manager to make it better.
  3. A training project that new Ignition developers can look at to see how to do things right and to provide Ignition work they can to do that is useful and that improves their skill, knowledge and prepares them for development on other projects.

How it Will Work

I setup an Ignition Gateway that is available over the Internet here I created the "Perfect Project Manager" project in that Ignition Gateway. People who want to help develop the project can log in to the Ignition designer and develop the project there.

I created a document that lays out the initial functionality that Perfect Project Manager (PPM) should have. See it here: Initial Functionality for Perfect Project Manager (PPM). This document gets the project started by giving initial direction on what to implement.

I created a spreadsheet that shows who is working on what. Eventually we will replace the spreadsheet with PPM for managing the project. The spreadsheet is here: PPM Functionality To Implement. The spreadsheet will be updated when more people are working on more things.

I created a google group for discussion about the project. This group is for discussion of ideas for the project, for getting to know other members of the project and coordinating work on the project. The group is here: Perfect Project Manager Development.

How to Get Started

Generally here's how things can go:

  1. Join the Perfect Project Manager Development google group.
  2. Read the "Welcome message" in the google group and the documents linked to in that message. Spend a little time getting familiar with the project.
  3. Introduce yourself in the "Introduce Yourself" topic.
  4. I will setup a username and password in the Ignition Gateway so that you will be able to login to the Ignition designer and implement functionality. I will email you that information.
  5. Find out how you want to contribute to the project. If you want to implement a new feature then find out what you want to implement. If needed you can create a new topic in the google group to ask questions to get more data. You can also contact me.
  6. Create a new topic in the google group to propose what you want to do or what new features or change you would like to work on. Describe what it is and why it should be done.
  7. Wait for feedback from people and a response from me about it before working on it.
  8. Implement your proposal using the Ignition Gateway I provided for the project.

Because this is the start of a new project how things are done may change and the above suggested steps don't have to be followed rigidly. I appreciate any help and suggestions on how to run and organize this project to make things better and smoother.

The Perfect Abstractions Ignition Project Development Style Guide should be followed when developing the Perfect Project Manager. Suggestions for adding more to the style guide are appreciated.

The PA Power Scripting Module has been updated to work with Ignition 7.8. Download here

The PA Office Document Module has been updated to work with Ignition 7.8. Download here

Inductive Automation released a new pricing web application. You can choose various packages, Ignition modules and functionality and get prices instantly. Check it out. Zack Scriven writes details about it on his blog.

In a recent forum post Carl Gould describes Ignition price changes:

Yes, the pricing changed. I wouldn't expect this every year, but this year we did make quite a few adjustments, as you all noticed. We felt that the improvements to the Reporting module warranted an increase in the price. However, I would draw your attention to the fact that we dropped the price of the Vision module by more than the increase to the Reporting module. We also split the Tag Historian and SQL Bridge products in order to drop the entry point for a number of types of packages, allowing us to offer the new Foundation package at a sub $10k price point, a package with no limitations whatsoever. We also dropped the price of alarm notification module. We've decided to start charging for drivers in order to help fund development of more protocols, so make sure your new quotes don't include drivers you aren't going to be using. I hope this demonstrates that prices were adjusted, up *and* down, all around, this wasn't a general price increase.

Also, I think you may have missed one of the major new changes: the price of redundancy dropped significantly. Redundant gateways are now priced at 50% of the primary gateway! This means that a Redundant Pro is *less* than Mission Critical Works was.

Here's a list of new features and changes in Ignition 7.8:

New Reporting Module

The new reporting module is just as flexible and powerful as the old reporting module but has a significantly improved user interface for designing reports.

The new reporting module is using the same underlying reporting engine as before, so leaning the new reporting module will be easy for anyone already familiar with the old reporting module. But designing reports will be much easier because of the interface improvements.

The old reporting module only worked with the Vision module. It was not possible to have reports without the Vision module installed. The new reporting module is different - it can exist and work standalone, without the Vision module. But the reports created with the new reporting module can still be used in Vision clients.

The new reporting module is also backward compatible with the old reporting module. So if you upgrade the reporting module to the new one existing reports will still work. Existing reports will be the same after upgrading to Ignition 7.8.

It is possible to convert old reports to the new reporting style by following the instructions given by Kathy in this forum post:

Scheduling reports to be generated and sent to people was a real problem for the old reporting module. This is solved in the new reporting module with built-in functionality to schedule the generation and sending of reports.

It appears that Inductive Automation tried to keep the flexibility and power of the old reporting system and at the same time fix its failings -- and it looks like they succeeded brilliantly.

I am really excited about the new reporting module in Ignition. It's a whole new ball game for creating reports in Ignition.

Check out the new reporting videos on Inductive University to learn more.

New Ignition User Manual

Ignition 7.8 has a new Ignition user manual. The online version allows users to add to the documentation by submitting comments. Check out the new Ignition user manual.

Gateway Network

The Gateway Network, new in Ignition 7.8, provides a way for Ignition Gateways to communicate between each other. The Gateway Network is provided by the Ignition platform, not by any Ignition module. The Gateway Network is exposed to Ignition module developers so it is possible to develop new features that use it. Inductive Automation plans to develop new features that use it. The new Enterprise Administration Module module uses the Gateway Network. See Gateway Network documentation to learn more.

Enterprise Administration Module (EAM)

The EAM module allows a user to monitor and control any number of Ignition Gateways from a central Ignition Gateway. See the documentation for more information.

Selectively Publish Resources

Ignition allows developers to makes changes to projects and save those changes without publishing those changes to Ignition clients that users are actually using. This allows developers to make changes and test those changes in staging clients before publishing those changes to their users. Ignition 7.8 adds the ability to select which resources to publish. Before Ignition 7.8 there was no choice -- everything would be published or nothing.

Now developers can make changes to a lot of resources like windows, Python modules, templates and reports, save those changes and selectively publish any of the resources when they are ready.

Publishing specific resources is done by clicking on the File -> Publish Selected... menu item in the Ignition designer. A popup window allows you to select which resources to publish.

New Interactive Script Console

The Script Playground in the Ignition designer has been replaced with a new interactive Python console. Here's what it looks like:

SQL Bridge Changes

The Tag Historian functionality in the SQL Bridge module has been taken out and put into its own module, the Tag Historian module. In addition the Tag History Splitter module has been integrated into the Tag Historian module.

The SQL Bridge module is now just transaction group functionality.

Copy & Paste Bindings

This is done by binding something to a property. Then right click on the property in the Property Editor and select "Copy Binding". Then right click on a different property (on the same or different component) and select "Paste Binding".

Copy Custom Properties

You can now copy custom properties on one component and paste them into another component. This is done by opening the Custom Properties editor on one component, selecting the custom properties that you want to copy, pressing Control-C, exit the Custom Properties editor, then open the Custom Properties editor for a different component and press Control-V. This copy and paste operation will also copy and paste the values of the custom properties.

New Ignition Module SDK

Inductive Automation released a new Ignition Module SDK that uses Maven, a software project management tool. The Ignition Module SDK is no longer downloaded from the Inductive Automation website. Instead Maven with the new Ignition Maven Plugin is used to get module development started. See the new Ignition Module SDK documentation for more information.

New OPC-UA Drivers (DNP3, Omron)

Inductive Automation released a new OPC-UA driver for the DNP3 protocol. See more.

A new driver to communicate with the Omron NJ series of controllers will be released soon.

Improved runScript Expression Function

The runScript function has a couple new features. When runScript executes a Python function it can now take additional arguments that are passed into the Python function. In addition, runScript can now reference custom methods on components by using "self" to refer to the component runScript is used with. Here is an example expression:


In the example above "self.returnText" refers to the returnText custom method on the component that the expression is used on. The 0 is the polling rate. The specific value 0 turns polling off. The "neat" argument is passed as an argument to the "returnText" method.

The ability to pass arguments to Python functions in this way is much easier than alternative ways and executes a lot quicker.

The ability to use "self" to reference a component makes it possible to directly call custom methods on components with runScript. This was not possible before.

Improved Custom Functions

Python functions have built-in functionality for handling default argument values, variable arguments and keyword arguments. Custom methods on components now support these. Here's examples of different argument functionality:

#default argument value
def returnText(text="No Text"):
   return text
#Passing in an argument is optional since a default value exists
print returnText()

#variable arguments
#the args variable will contain a list of all arguments passed into the function
def returnText(*args):
   print args
returnText("first arg","second arg","third arg")

#keyword arguments
def returnText(**kwargs):
   print kwargs
#kwargs becomes a dictionary with the items: {'f':'first','s':'second'}

Power Table Improvements

The Power Table component has a new property called "View Dataset" which contains the data in the table as it appears on the screen, after any column hiding/sorting/re-ordering and filtering.

It is now possible to select rows on a power table, press Control-C (copy) and then paste the rows as text into a text editor or other places.

New Scripting Functions for User Schedules

New scripting functions have been added for getting/adding/editing/removing schedules and holidays. See the new scripting functions in the documentation.

New Scripting Functions for Rosters

New scripting functions have been added for getting and creating rosters. Rosters are used to send alarm notifications to users. The two new scripting functions are system.alarm.createRoster and system.alarm.getRosters.

Roles for Creating Projects

Ignition 7.8 added functionality to specify what roles users must have in order to create new projects. The roles are specified in the "Gateway Settings" webpage in the Ignition configuration web application.

Popup Windows Can Overlap Docked Windows

A new option allows popup windows to overlap docked windows. See the image on the right to see this in action.

The new option exists in the project properties of a project in the designer, specifically: Project Properties -> Client -> User Interface. It is a checkbox called, "Prevent Popup/Docking Overlap".

New DataSet and Array Tags

Tags in Ignition can now hold arrays and DataSets. Query tags can now hold multipe rows of results by storing them in a DataSet.

BestFit Layout Mode for Template Repeater

The new "Best Fit" layout mode for the template repeater fits the template instances within the repeater without scrolling and maintains aspect ratios.

Ignition Titles

Web browser tab titles and Ignition designer titles show the system/server name of the Ignition installation being used. This helps differentiate different Ignition installations when using more than one at the same time.

I am happy to announce the release of PerfectChat. It is a new product from the Perfect Abstractions Ignition development team.

PerfectChat is instant messenger and chat functionality that is very easy to use and add to any existing Ignition project that uses Ignition version 7.7.5 and up.

PerfectChat is freely available to anyone who wants to use it.

It takes less than a minute to install. It does not use a database connection so no database setup or configuration is needed.

It has no configuration. It just works. Here's what the chat window looks like:

Chat Window

Chat messages are stored in memory. They are collected and available as long as the client is running.

Messages can be sent to individual users or to a group chat room.

People can chat with each other even though they are using different projects. The projects need to be running on the same Ignition Gateway.

PerfectChat includes a south-docked notification window that gets displayed when the chat window is closed and a chat message is received. It notifies a user that he/she has received a message. It looks like this:

Chat Window

Clicking on the notification window will close it and at the same time open the chat window and select the user that the message came from.


An Ignition template with a button is used to install PerfectChat. Pressing the button executes special functions from the PA Power Scripting Module that ensure PerfectChat resources are installed without overwriting any existing resources in the project. This enables PerfectChat to be installed in any existing project safely. Here's what the "PerfectChat Installation" template looks like:

PerfectChat Template

The installation of PerfectChat requires that the PA Power Scripting Module is installed. The PA Power Scripting Module does not need a license to install PerfectChat. There is absolutely no license or cost for installing and using PerfectChat. It takes 2 minutes to download and install the PA Power Scripting Module.

Here's how to get PerfectChat running:

  1. Download this project file: PerfectChatInstallation.proj.
  2. Using an Ignition designer import the project file into an Ignition project.
  3. Open the "PerfectChat Installation" template that was imported.
  4. Put your Ignition designer into preview mode and click on the "Install" button.
  5. Installation is complete. You are done and there is nothing to configure.

You can now launch a client and open the chat window from the client menu. Here is what the menu looks like:

PerfectChat Template

The "PerfectChat Installation" template can also be imported from Inductive Automation's public cloud templates repository. It exists in the "Chat" category.

I created a video that shows the installation and PerfectChat in action. Video link: PerfectChat for Ignition Projects

The PA Power Scripting Module does not need a license for installing PerfectChat because all scripting functions provided by the Power Scripting Module work without a license when run in the Ignition designer. Since installation of PerfectChat is done in the Ignition designer all of the functionality of the Power Scripting Module can be used without any cost or license. PerfectChat itself does not use the Power Scripting Module.

I do suggest purchasing a license for the Power Scripting Module if its licensed functionality will be useful to you and/or save you time. Here is an article about some of its features: PA Power Scripting Module

PerfectChat was developed by the Perfect Abstractions Ignition development team. Please, feel free to contact us on any question about the chat usage or any development needs or consultation.

Some discussion and improvements are in this forum thread: Add Instant Messaging and Chat Functionality to Any Project

Phil Turmel, from Automation Prefessionals, has been working on some interesting new Ignition modules.

The Time Series Database Cache module was recently released on Module Marketplace.

The Time Series Database Cache module supplies dataset manipulation and database query functions that are optimized for use with large and/or high-resolution database tables containing timestamped data.

Check out the documentation for more details.

Simulation Aids Module

Phil recently released a public beta of a new Ignition module called the Simulation Aids Module. This module helped Phil test projects in-house when physical components were off-limits or didn't exist yet. See Phil's post on the forum about it.

Dream Team Consulting is delivering the Ignition Core Training and Ignition Advanced Training classes in Sweden.

So if you are in Sweden or Europe it might be more convenient to take the classes there.

Having a consistent style when developing Ignition projects helps keep developers in agreement on how projects should be developed, facilitates communication and makes projects easier to understand and maintain.

I've been working on a style guide here: Ignition Project Development Style Guide.

I want the style guide to use conventions that most people are using already, so if the guide says something different that what you have seen or like, let me know.

I don't use client tags in Ignition much. Not because they are bad or something like that, but because there is something better: module level Python variables.

Python module level variables and client tags are both ways to store and use global data in an Ignition client.

Python module level variables don't have the following limitation: Client tags can only use a few Java data types.

Client tags have one data type for holding aggregate values, the dataset. Datasets are terrible for accessing, setting and manipulating data compared to Python dictionaries and lists. In addition datasets enforce a structure -- rows of the same kind of data. Python dictionaries allow you to structure and organize data in a way that is best suited to the data and how you use it. That makes short, easy to read and write maintainable code.

Python module level variables can hold data of any data type. In my experience Python dictionaries and lists are the most useful data types for storing and using global data in Ignition clients.

It is also nice that Python module variables can be defined in the same place as the functions and code that manipulate them.

Client tags have useful scalar data types like Integer, Float, String and so is most useful for holding single value data.

What About Tag Change Scripts and Other Client Tag Features?

Some client tag features are easily implemented in simple Python code. Here is a simple example that implements value change script functionality:

#project.machines Python module
#create module level variable
_machineConfig = {}
#create functions for setting and getting machines that can be used anywhere in the project
def addMachineConfig(machineID, config):
    _machineConfig[machineID] = config
    print "new machine config added:", config

def setMachineConfig(machineID,config):
    if machineID in _machineConfig:
        oldConfig = _machineConfig[machineID]
        _machineConfig[machineID] = config
        #value change script
        print "oldValue:",oldConfig, "newValue:",config

def getMachine(machineID)
    return _machineConfig[machineID]

Noticed that "value change script" code is executed any time a machine's configuration is changed by using the setMachineConfig function.

Here's a great comment from Alasdair Barclay (AlThePal) about this blog post:

As we got to know Ignition better we moved from the pointy-clicky interface to doing more things in code. It is more flexible but it's harder to get started - most beginners will need the pointy-clicky interface until they understand the concepts, then they can move to coding directly and enjoying more power.

GStore was some functionality I built into the Power Scripting module. It developed over a short time and now I think it is best to get rid of it.

GStore is short for global storage. It was a way to store global data in Python variables in Ignition projects. The main problem with it is that there is already a great way to do it -- just store global data in Python project modules. I thought I could add various functionality to gstore to make it more unique and useful. But I found that I could add the same functionality in more general ways.

GStore still exists in the Power Scripting module for backwards compatibility but I removed it from Power Scripting documentation and its use is no longer recommended.

GStore answered this question very clearly: "How can I store and use data globally in an Ignition project in a very flexible and dynamic way during runtime in an Ignition client?" But the best answer is use a Python module library; create a module level variable and functions for setting and accessing it, then use those functions in your application to store and manipulate global data.

Here is a simple example:

#project.machines Python module
#create module level variable
_machineConfig = {}
#create functions for setting and getting machines that can be used anywhere in the project
def addMachineConfig(machineID, config):
    _machineConfig[machineID] = config

def getMachine(machineID)
    return _machineConfig[machineID]

I really want to build new and useful things into the Power Scripting module, so let me know what you want.

More blog posts...