New MQTT Updates for FT Optix v1.8

Home / FactoryTalk Optix / Optix for Edge

Description
With the new v1.8 release of FactoryTalk Optix (October 2026), Rockwell Automation has enhanced the native MQTT capabilities. This video demonstrates those new capabilities which include:

  • Runtime event data streams to an MQTT broker so external systems, supervisory applications, or cloud tools consume event information.
  • The MQTT client supports complex data types to exchange complete data models through MQTT, which reduces engineering effort and improves scalability for industrial IoT and edge applications.

Download the sample project used in this video: https://github.com/FactoryTalk-Optix/Training_Loggers

Download MQTT Explorer: https://mqtt-explorer.com/

Software used for the demonstration:
FactoryTalk Optix v1.8
MQTT Explorer 0.4.0-beta.6

Transcript
(00:02) In this video, I’d like to take a look at the new MQTT features that are in the version 18 release of Factory Talk Optics. Version 1.8 just came out at the beginning of October 2026 and there were a couple of improvements to MQTT. Um, many are still interested in SparkPug B. Uh, that is not uh released yet, but we’ll be kind of in an upcoming release of Fecker Talk Optics.
(00:30) But if we um look at the factor talk optics studio and if we go to the question mark and release notes, you can always see what comes about in in the latest release. And we got the 18 system features here. And they’re always categorized by kind of their you know um capabilities or you know kind of core concepts.
(00:53) And if you look under the data connectivity section, we can see there are a few bullet items that got added here. Um, one is a new device driver that will enable Optics to talk directly to Power Flex drives. Um, so that’ll be something we can look at here in a future video. But today we’re going to look at these two second bullets which are on MQTT.
(01:15) Um, one is the ability to send an event logger to the MQTT broker and the second is support for more complex data types and um some of the metadata that you could kind of put into those uh complex data types or into a variable. So, let’s take a look. Um, and then for this example, I’m going to use uh one of the ones that comes from GitHub.
(01:48) So, get this is Rockwell’s repository of optics applications um that you can download completely for free without having to have any special um GitHub other than a an account perhaps to log in, a free account. But um I went to the repository and uh just typed in event and there are a couple of projects that come up u but one of them here is the training for loggers and I’m going to use this one [clears throat] because it’s pre-built and it has the event loggers and a data logger already configured.
(02:26) So here is the project. So in a in a previous release of optics um you know there were some MQTT improvements where you could actually take a a data logger and stream a data logger right to MQTT. Um also from the previous versions you know you were kind of limited to if you were creating a publisher you could just send like one folder at a time um in that publisher.
(02:58) Now we’ll be able to do a more complex folder structure as well as um you know kind of a you know more complex data types such as an object data type. So if you can follow along you can actually go and download this project and uh and do the same things I’m going to do. It uses uh the simulate uh the variable simulator that comes in the template library.
(03:22) So, no need for any kind of controller um or emulator other than the the one that’s built into optics. Um, and I’m going to also use another free tool here, just MQTT Explorer, to just look at the MQTT data that gets published from Optics. So, I’ll have it preconfigured here to look at my local host, point to the default port that Optics will use.
(03:50) uh optics will default to 88 uh 8883, but you can of course change that to 1883 and we’re not going to have any um security or uh certificates to kind of contend with for just our demonstration. So in this project, let me just show you around real quick. Um like I said, we had our um variable simulator under Net Logic.
(04:18) We have three data loggers that were preconfigured in here. Uh data logger one is actually going to be logging just the data and we have the two event loggers for when we have an event. Um one event will be a change on a variable and the other one will be uh some session um events such as like a a change in um ro um perhaps. And then there’s only going to be one data store and that is an embedded database.
(04:48) Um then if we look at the model folder, this is where you know we can um where we’ll kind of demonstrate the ability to send an entire kind of folder structure or an entire name space uh through MQTT. So under under the model we have two uh folders created. One is audit variables um variables one two and three and the second is the data logger variables which are the sign cosine and ramp and that’s what gets created in this variable simulator um net logic.
(05:24) Um, so if I go ahead and just start the emulator and um we’ll just take a look at this what this looks like real quick before we add our MQTT um content to it. So here’s our runtime emulated runtime. Um so we can see we have some data moving. We have a sign, cosine and a ramp. And uh we can adjust um our kind of sampling mode mainly for the put you know putting the data into this data grid that doesn’t affect the MQTT um publishing that we will do.
(06:03) The other two tabs here are the event loggers. So one of these events is um variable audit. So if I were to change some variables here, uh, and I do a refresh, you’ll see that we’ve got an old value and a new value. So, so these are going to be kind of, uh, change events and we can capture what it was and what it changed to.
(06:29) And then this other tab is the session uh, event where we’re actually looking at the user audit. So, it engineer, right? So, we can just quickly simulate some events with this project. And again, this is uh completely all done um available for you to download off of GitHub and just kind of play around with, tweak, or um you know, take some of the pieces out of it and uh use it in your own projects.
(07:01) So, I’m going to start uh or stop that emulator. And now we’re going to go ahead and add the MQTT pieces to uh to show some things here. And we’ll kind of minimize some folders here. Now note in the in the project that came from GitHub, there is not a uh MQTT folder. Uh so we don’t have an MQTT um folder ready to go.
(07:26) Well, not to worry. We can come up here to the to the top level and rightclick and we could say new and MQTT. And there’s this MQTT1 that gets created. You of course rename that if you want. Um we’re going to say right click on that. We’re going to say new and we’re going to say first we’re going to create a broker.
(07:50) So we’re going to have optics as the broker. >> [sighs] >> So for the broker, we just need to make some basic configurations. One is the port and like I said earlier, our default is 8883 and we can go and keep that for the moment. Um, typically it’s either going to be 1883 or 8883. Uh, for MQTT traffic, um, we’re going to keep everything else the same.
(08:12) You know, the connections, the QoS, um, the inflight and stuff. The only thing I do want to make sure we change here uh for this to work since we’re going to be um doing this with no authentication and no certificates is we do we do need to change this anonymous authentication from false to true. It’s a little bit of a tricky thing that we’ve encountered um in our previous MQTT videos is that if you know if you do want to uh treat this as an anonymous authentication then we do need to change it from false to true.
(08:50) So that sets up the broker. It’s all we got to do. Um next we’re going to rightclick on MQTT1 again and we’re going to this time choose a client. We’re going to add a client. And for the client, we’re going to tie it to the local host to the embed into the embedded broker that we just created. So, we’ll say um local host.
(09:11) We’ll make sure the port is matching. So, 8883. We have to have a unique client ID. And at this moment, this is the only client ID um that we’ve created. So, we can keep that as default or you can rename it to something else. Um the version, we’re going to keep that at 5.0. Uh we do have an option between 50 or 311 but it is a 50 um version that we’re using.
(09:36) Now uh since we are for demonstration we’re not using any security we will disable the SSL. We will disable the validate broker certificates and we will keep our uh identity type as anonymous. So we created the client but now we need to do the publisher. So, we’re going to right click on that client and we’re going to say new publisher.
(10:02) Notice we have the options to be either a subscriber or a publisher. In this example that we’re doing, we’re going to publish data out of optics to the MQTT broker. So, it’ll be will be a publisher. So, here’s where we get to um kind of show the the new stuff, right? So, um we have you know first you know what is your you know what do you want to do? Do you want to sample on periodic or change in value or none? I’m going to keep it periodic.
(10:34) Um, and then you can change your sample rate. And then what we want to do is we want to choose um the the data source first. So right now it defaults to folder. So we so before we had the option for folder and data logger. Now with 18 we have the ability to add the event logger here. So with this first one um let’s go ahead and keep it folder and we’re going to publish the entire model folder which gives us you know all the variables and the the variables that are nested under these folders.
(11:08) So we’re going to um scroll and we will find model and we will just choose that. Now for the uh for this to work we do need to give it a topic name. Um I’m going to call it optics. So, I’ll put a period [snorts] and we’ll call it folders or folder vari folder variables perhaps. We’re going to go ahead and create two more publishers.
(11:38) Um, one for the data logger and one for the event logger. And we’ll give each one a unique topic name so we can see it um in our MQTT uh tool. Everything else here will stay will remain the same. We’ll just keep it default. So if we were to start the emulator right now, um we basically would be publishing um all the folders that all the variables that are in the model form.
(12:03) So let’s go ahead and create our our second publisher. We’ll right click on client again. We’ll say new publisher. This time we’re going to change it to the data logger just to see how the data logger works. So, uh, then the option here is what data logger do you want to stream out to MQTT? Well, we only have one to choose from. So, we’ll choose data logger one.
(12:29) And for our topic, um, we’ll call it optics so we can identify, you know, where it’s coming from. And then data logger perhaps. And everything else will remain default. So now we’re publishing the entire model folder and we’re publishing the uh like a live stream of the data logger essentially.
(12:55) And the last one we’ll set up is the third type that we now have available to us and that is our event logger. So I I rightclicked and created a third publisher. We’re going to keep the uh sampling the same. This time we will choose event logger and we will choose. So now we have two to choose from either the event logger one or event logger two.
(13:20) So let’s go with event logger one which will be if we change the variable um in the project or you know during the runtime. And for the topic we will give it a name of optics again just so we can kind of identify where it’s coming from. and let’s call it event logger so we know where that data is coming from and everything else will stay default.
(13:46) So let’s go ahead and start the emulator. Once the emulator is running, there’s going to be really nothing different to see as far as the the project or the runtime. uh because we’re now, you know, all we did was we added MQTT and kind of publishing that out. Um but we’re going to open up our MQTT uh explorer tool and we will uh make sure we’re connected on the Vector Talk optics and all of our settings here are correct.
(14:25) Make sure the certificate and encryptions are both turned off and we’re going to say connect. So you can see right away um we’ve got two entries in here. Uh we have data logger and the folder variables. So these are updating every second. And if I were to click on one of these and I’ll kind of blow this up a little bit. Um we can see that uh we can see the JSON uh string in here.
(15:01) or the JSON code that comes from the broker that shows us uh everything. So the first one was our data logger. The data logger had three variables in it. The sign, the cosign, and the ramp. And we could see the red was um the previous value, and the green is the next value. And um if you’re not familiar with MQTT Explore, they have this little kind of squiggly line on the green.
(15:26) So, we can actually create trends down here um of those variables as they change. If we’re to click on the folder variables, we’ll see that we have the um all of the variables from the model folder. So, the tag name has um you the tag name and then the value. And then if we scroll down a little bit, you’ll see you know audit variables slash variable one, variable 2, variable 3.
(15:52) So folder name variable name value and then we can see that the uh there’s so there’s been no change. So therefore it’s still zero and then the the sign cosine and ramp under the data logger variables are changing just like they’re were changing from the data logger. Now we didn’t see an event here because we didn’t trigger an event yet.
(16:16) So if we come to the variable audit and if I start to change some of these variables and we see now that we have our optics event logger um topic starts publishing data into here. And if I right click or I should say if I click on top of that highlight that we see in the um in the value fields over here the JSON. So we can see that we get um a couple of records.
(16:49) We get a timestamp, we get the local time, we get some information about the uh client. But down here we see we get new value, old value. So see the source node variable three, the new value and then the old value. So we can see actually it changing what it was and what it became both the new and the old. So um so we can actually now you know stream so to speak the uh events the event log um straight to MQTT.
(17:25) So we can publish those events that might be happening uh we can publish our data log um through MQTT or we can now uh publish our entire model folder as well. Now, one thing I didn’t uh demonstrate here is that not only if we chose the folder option to publish, not only do we get all the variables that come underneath um the model folder or whatever folder I choose to uh to publish, if I were to create uh some of that metadata that I mentioned, for instance, if I were to come to data logger variables and if I were to kind of rightclick and say let’s add um range. So if I were
(18:14) to set like a low and a high limit range, these values will now get passed along with uh MQTT as well. So, not only do we get the entire kind of name space, but we can also kind of get the kind of the the rich metadata um that’s associated with those tags if we choose to use that in the optics project. So, that’s just one of the new features of version 18.
(18:49) Um so, just some enhancement to MQTT um as far as um both publishing as well as subscribing. So the it it it the same kind of capabilities um as far as the the the folder structure will work if you’re subscribing to data into MQTT or into optics as well as if you’re publishing um directly from optics.

Tutorial List

Back to tutorials