Hi, my name is Tricia and I'm the commercial portfolio manager for
FactoryTalk design studio. in today's session. We're going to talk about what
FactoryTalk
design studio is and the value that it's delivering. I'm going to spend about half of
my time in the presentation and then move into demonstrating the product then we'll
close out with some reminders. So getting started here, let's talk about why we built
FactoryTalk Design Studio this data that you're seeing here on the slide
Read that was taken about two years ago of folks in our industry. The main idea here
is
how is digital transformation going from a design perspective on the left hand side. You
see that people are looking at how to modernize the development platforms that
they're using and over on the right side there looking at the adoption of
collaboration tools. This probably isn't news to any of you
watching and it wasn't news to Rockwell either.
We understand there's been a large amount of it demand for updating design tools for
making them more focused on building a system
for making them more integrated. So you're reducing the number of total tools and
there's a focus on collaboration as well. So how do you bring multiple people together?
How do you bring those people together when they have different skill sets
across an entire life cycle and then finally just modernization overall.
How are you using new technologies? And how are you able to
capitalize on new workflows that are part of our world? Date, so that's
kind of where Rockwell began with this idea of needing to create something that would be
able to focus on system design. So we built FactoryTalk Design Studio A
cloud-based environment for Industrial Automation design is built from the ground up
to be new and to only exist in the cloud. And when I say its cloud-based that means that
the product was built to run exclusively in the Rockwell public cloud and to be able to
provide a software-defined presence for system
design. So what makes this different from
other products in our portfolio? Like for example Studio 5000 Logixs designer.
Some of you are probably Logix designer users.
It's our you know, Premiere on-premise
Industrial Automation design products. So what makes Design Studio different than that,
well here you can see the 3m's modern multi-user and multi controller
by modern we mean That we're bringing modern software development work flows into
Industrial Automation. So think about that in terms of object oriented programming and
integrator integrated management of libraries multi-user is just like it sounds
we want to be able to build tools that allow multiple people to work together
simultaneously, but we also want to be able to focus on bringing people with different
skill sets together in the same environment. And then finally you see their multi icon
Controller again just like it sounds being able to manage and configure multiple
controllers
in the same project. And so if you think of Studio 5000 logix, it's One
controller per project, but we want to go beyond that with design studio. We want to
have all the controllers that you need in your system be programmed in one single
project. So we're able to give you more context on what that system is doing. So,
those are the 3m's we typically you typically hear. Russ talk about to describe FactoryTalk
Design Studio a modern multi-user multi controller system design environment that's
available in the cloud before we jump into
details on FactoryTalk Design Studio. It's helpful to talk about where it fits in
our portfolio. And that's in the factory. Talk Hub. The FactoryTalk Hub is where all
the cloud products that Rockwell automation is producing all come together in a single
environment
It's the front door of our cloud-based product portfolio
and more than that. It's an ecosystem. It's a set of services that combine all these pieces
together. So you see underneath the FactoryTalk Hub
here that there are three different areas that we can work in the design Hub the
operate Hub and the maintenance Hub. If we double click on the design Hub, these are
the products that live in that environment today.
The idea here is again, That all these products exist in the same
place and can share data in an integrated experience.
So if we dive a little deeper on FactoryTalk Design
Studio, it's all about building and deploying systems faster collaborating across diverse
teams and geographical locations and designing an entire system based on what it
needs to do rather than where it's executing. So let's dive into each of these topics here
in the presentation then we'll then Jump over into the environment so you can see
some of these key Concepts in action before
The first thing I do want to emphasize again is that design
studio is cloud-based. That means that it's available anytime anywhere. You can see over
on the right hand side of this slide that all you need is a Chrome browser to access the
environment one of the things that we've heard time and time again, is that managing
software is a necessary tasks that can adversely affect team productivity. the nice
thing about design studio is you don't need to download and install or activate any
software nor do you have to manage any of the
any updates for the software? So so think about that in terms of patches or
security updates instead you'll always be working in the most
up-to-date software that lives in the cloud. So think of it as Evergreen,
so that's kind of the first piece of the modern experience.
The next thing we want to talk about when we talk about Design Studio being a modern
experience is the concept of object oriented
programming what we're doing with FactoryTalk smart
objects is setting that Foundation. We're putting all this functionality into a
single object and then we're simplifying how you interact with that object by
being able to pass data in and out of it. So that's the first piece. Some Modern after
the idea that it's all existing in the cloud and we'll dive into this more in the
demonstration. The other thing I want to talk about here
is integrated out libraries. So when you think about object-oriented programming and
FactoryTalk smart objects, we also want to provide the ability to manage those objects
in a library. That's what the idea of having an integrated
integrated Library means you don't need to go to an outside product to
be able to manage those definitions. Missions or instantiate them into your product project
instead. What you'll do is you'll create those definitions directly in the library.
And then you can see from the screen shots here that we can also have an add-on
instructions and user defined data types in the library as well. So we know that those
are something that a lot of our studio 5000 logix-xt signer users are accustomed to
using in their projects. So we have made those available in Design Studio as
well. So today we have an integrated project library in Design Studio, but I
will have this concept of a shared library that can be shared among multiple projects in
the future. So the library allows you to do things like version version controller
object. So, you know, which version is instantiated out into the project and also
delivers integrated inheritance, which means if you change an object definition in the
library all instantiated object Jake's based on that definition inherit that change
without any work required on your part.
Another thing that makes Design Studio modern and also goes into that that topic of
multi-user is the idea of integrated GET technology.
If you're familiar with distributed Version Control
called GET we are integrating that directly into Factory talk Design Studio.
This is a newer concept for or designing industrial automation systems.
So having integrated Version Control gives you the ability to track all of your project
changes and seamlessly collaborate on the same projects with your colleagues.
You can see here in the screen shot on the right that there's a description
of the change. There's a time and a date stamp of when the edits occurred.
There's the person who made them in the form of an email address as well.
So all the things that you would expect to see as part of your Project change history,
all of that is captured as you are editing and making commits in your project.
It's sort of like a milestone in your project or a known
good State and what it allows you to do is increment
that change history to see who's making changes
and what they're doing in the project. It also allows you to do detailed comparisons.
So you can see on the lower right? I'm able to do comparisons of one point in the history
project history to another point in the history so I can take
my latest changes and compare them to several changes ago.
So maybe that's part of a troubleshooting a port or maybe you're just kind of
looking through there to make sure you understand the changes that have occurred at
a certain point in time. Now, you'll notice also in the lower right
corner that comparisons are currently tax base
that will not always be the case. We are also Toward having a
comparisons available graphically as well.
So Switching gears. We want to talk just touch here on Multi the
whole concept of multi controllers. We recognize that the complexity of the
systems that our customers are building or it's always growing. It's always changing.
So that's where this idea of having multiple
controllers in the single single project comes comes in.
It's not just about having you be able to
manage everything. Everything in a single file so that you don't have to worry about
multiple projects files. We also want you.
We also want to give you the ability to have everything in
one place and also to not have to worry so much about firmware in the controller
earlier when I was talking through this idea that we would always have the
software up to date that it would always be Evergreen
you might have been wondering. Well, what about the controller firmware? Doesn't
it have to be compatible with the software?
Answer is that starting with version 34 of Logics controller
firmware and then Moving Forward Design Studio will be able to manage all
those firmware versions for you. Meaning that you can support multiple
versions of controller firmware with the same software.
So worrying about the compatibility of the software in the firmware will be a thing of
the past. You just open your browser to the design studio environment and whatever
is running there in the cloud will be able to talk to you version 34 firmware and forward.
Now before we go any further, I wanted to address
this whole idea of Hardware obstructed design. So what does that
mean? We want you to be able to design your system
based on what it's doing and not be so focused on where it's executing.
We think that by doing this you'll be able to deliver a project that's
really easy to understand not only for yourself but also for your end user to
understand so they'll just be looking at a system model
and what their Is doing and they'll be able to troubleshoot
it in that way. If you worked in other automation design software, you typically
start by defining what controller you're working in and Studio 5000 logix ai designer
is
no different. But Design Studio in Design Studio, we change that workflow. We want you
to be able to map out what your system is doing create your logic add your
controller and then add your controllers and hardware at a later date and then you'll be
able to vine that logical content to the execution
devices using a project called allocation which will touch on in the demo. So you still
have all the ability to get very detailed with granular execution of your projects.
But now we're also giving you the ability to think logically about building out the system
model about building that context that you want to
deliver the data in and then being able to assign it
to the execution devices. Okay. So what we're going to do now is we're
going to go ahead and jump into the
FactoryTalk design studio environment. And then what we'll do is we'll come back and
wrap things up towards the end. So before we get into
the design studio environment, I want to give you a quick idea about that front door to all
the cloud based products that were building here at Rockwell. So that's what we're
looking at. Now. This is FactoryTalk Hub. This is what it looks like today.
Once you enter your credentials, you will see something that looks like this.
This is these are the products that are available
on the Hub today. And as we continue to build out more and more
products, you'll see those alongside the ones you see here,
but the way that I logged in is using my Rockwell Automation account and by my
Rockwell account, I mean the same one that you would that you would use to log into
your into our knowledge base. Ace so using that same account you can log into
the FactoryTalk Hub. One thing. I do want to mention here is that this user is part of an
organization called FTD's demo that you see up here in the upper right? Organizations are
how you manage different users that you want to collaborate and share projects with so if
a user is not part of your organization,
they can't access your product projects. It's also the way that you manage
the products. That you can see so you can see here that some there are some
locks on some of the product product tiles here
in this view. That's because this organization the FTD's demo organization
doesn't have an entitlement for those products.
So if you're not familiar with what an entitlement is,
it's essentially the same thing as an activation. So instead of using Factory Talk
activation, you would imply apply an entitlement to that organization.
And that's what allows you to access that product.
So that's all I'm going to talk about here in the FactoryTalk Hub in terms of an
introduction. Now, let's go ahead and jump into the
FactoryTalk design studio environment. So my screen is shared out here and notice. I
have two side-by-side instances of FactoryTalk Design Studio. Don't worry. I'm
not going to make you look at this side by side the whole time but one of the things
that I do want to mention as part of the value of design studio is having multiple
people. All collaborating at the same time. So the reason I wanted to mention this
is that we currently have two users logged in and they're both looking at the same project
for now. I want to call your attention to the status indicator at the lower right corner of
each screen. You can see it right down here.
This indicates that both of these local projects on
these users PCS are completely synchronized with the main project in the shared
Repository. We'll come back to this
this user over here on the right here a little bit later.
I just wanted to let you know that somebody else has logged in and waiting to
collaborate with us. All right, so the screen that you're seeing
now is FactoryTalk Design Studio. The first thing I want to note here is these Explorer
panes Over here to the left hand side. These allow
me to see my project in different ways. I can see them based off of what my system is doing
here in the system pane. I can view the device pain to build out the hardware
required in my project. The execution pane is next and that's where I can see how and where
my code is executing and lastly we have the library pane
refined data types and smart objects
that are being used in Project. Next up here is
this is the integrated version control button experience. So up here.
I can commit changes to my project locally.
I can view those changes in my project history and then I can share the changes with
other users by pushing those changes
using this button right here and that pushes those changes to a shared repository and
makes them available for other users. I can also pull changes from the shared
repository when other users have made changes that I want to see in my local project.
So continuing on over here. I can also toggle these paints
on and off
using this button board button bar over here on the right hand side. So each of these
pains has a different purchase purpose. I can have an output. I have an
output pain
down here that I can view.
That is where errors and warning
indications are made. I made aware of
you can also see that there's a toolbox here, which is where I'm going to see my
ladder instructions. And we also have a properties pane over here
for all the different project elements and we'll see that in that action here in
just a little bit so you can kind of keep an eye on keep an eye on these pains as we keep
moving along and see how they populate with data,
but for now we can go ahead and end our tour and we we can
go ahead and start with the the topics. We want to discuss. So
moving on. There are the key topics. I want to talk to
you about today in the demo are I want to explain a little
bit more about this idea of object-oriented programming
and having an integrated library, and I also want to tell you a little bit more
about the code editor that we have available in
Design Studio working directly in text and then
Being that code that you have built out in the code
editor render graphically
and I want to show you how you can get your code assigned to a controller. We talked a
little bit about that in the presentation as you have been here
as you been hearing you can have multiple controllers also in one
product project so we can't just assume that there's only one controller
that were coding again. So we'll see how that works as well.
And then finally I want to tell you about get integration with multiple people working
together in The state at the same time and that's where that additional user is going to
come in towards the end of the the end of the presentation.
Okay. So let's start by talking about object oriented programming
earlier. We talked about this concept of Hardware abstracted design,
but I'm going to take a step back and show you a few that's probably more familiar,
which is the execution app view as we call it. So I've got my controller setup here
I've got I'm some tasks under here. I've
got a default task and then I've got programs and Associated
routines. So for you logix ai designer users out there. This probably looks pretty
familiar to read to you and we refer to this as the execution explore because we're
telling the controller what it's going to be executing were telling the code how it's
going to be executing and we're also saying where it's going to be
Ting now you might have noticed the spoiler alert here that we have two controllers in
this project that have been already been added here and that's for demonstration
purposes. I will come to that we'll come back to that
shortly. But let's go ahead into that original view,
which is the system pain. So instead of thinking about where the code
is executing we want to give you the ability to think about what it's
doing instead. So this logical view is available in what we call the system pain.
What you're looking at here is a clean and place
application. So you can see we have a three tank system.
I've got an an outlet valve. I've got a level
transmitter. I've got a pump
so on and so forth. So you can already see that. I've got things
already in here that are control modules. So instead of thinking about it in terms of
where the program
where's the program that's contains my pump. Where's the stroller that's running
this program or that program. I'm just thinking about it more in terms of
the actual model. So this is sort of a simple simplified
model. So that's what we mean
by the idea of The Logical layout and what's enabling this for us is the idea of a smart
object. So as you can see
some of these smart objects are used for hierarchical purposes. For example,
the SIP 100 level up here is the main part of the system, but it's not a direct code
container and it in and of itself you may notice that the SIP 100 icon next to
sift 100 is to interlocked hexagons what this indicates is that it
was inherited from an object that was created in the Library and we'll touch on that in a
few minutes. Now again, if I expand this out, you can see
the main components of the object itself.
You can also see that those objects have a white hexagon next to all of them.
This is what we call a Singleton smart object that allows you to easily set up the
hierarchy of your system.
Now if we expand out for example the wash tank here
you can see that this is actually
a code container. So we've got a control program
and then we have a main routine here. We can also if you click on the
smart object itself, we can all you'll also notice over here on the right hand side that
the properties pane populated and you can see that it's based on
a definition that's available in the library
called CM valve.
The main thing to remember here is that these are all Allure pieces of code that are
very portable for usability and can be instantiated throughout the project.
So if the definition is changed at any time, there's no work
to be done on your behalf as
because all of that those changes that are updated in that object in the library
will be inherited through all those instantiated objects.
Now, you may be wondering if these are modular pieces of code with no outside.
Dependencies. How do I pass data back and forth in the
answer is through parameter connections?
If we take a look at the outlet valve smart object and view its tags and parameters.
You'll notice that there's a designation regarding how the tag
will be used. Will it be a logix local tag? Will it be an input or will it be
an output
if we look at for example this tag right here
we can come over here to the properties Pane
and we can see that there have been connections that have been
set up here. So these connections are back to this.
Z control program that's in the root of the SIP 100
project. So that's how the communication between
objects works and where the object remains fully encapsulated
and the data gets passed in and out.
So now that we talked a little bit about this logical hierarchy and how objects get
introduced into the system. Let's talk about how we manage those
definitions and that's in the integrated Library. So right now we're showing here is
the system pane. And we're going to jog down here to the integrated into the library Pane
and we're going to take a look here. So you'll notice that there are three types of
content that you can manage here. We've got instructions user to find data types and
smart objects. Again, if your studio 5000 logix designer user you may be familiar
with another product in that in the studio 5000 Suite
called application code manager. It's
So a library manager that allows you to create objects
to import into to import into your Logics designer projects,
but here's here's one key difference. It's a one-way workflow with no inheritance
to speak of so the integrated Library here
and FTN FactoryTalk Design Studio allows you to manage all of your definitions in one
place and it allows you to have all of that integrated inheritance. If we Expand
out the smart objects folder. You can see here that we have these black hexagons listed
this indicates that this is a smart object Library definition and you can see the CM
valve that we talked about a little bit earlier is represented here as well. So
that's a quick and simple version of smart objects and integrated in the integrated
library. Now one thing I do want to remind you of I mentioned this in the
presentation, but right now we have integrated Library by project but in the
future we'll have this concept of a shared Library
what that means is that the the objects that are created and reside there
can be shared amongst all your projects in that organization.
Okay. Now, let's talk a little bit about the idea of the code editor. I mentioned during
the presentation if you take a look at the objects here in the
library, every single element here has its own text based file behind it,
which means you can dig in at any level. Will the of the project to the text-based editor?
So what I'm going to do here is I'm going to expand out the CM valve since we've been
already chatting about that and again, each of these elements here have a
text-based backing file. I'm going to go ahead and
right click here and I'm going on this routine and really I could have started
anywhere on the program or the smart object itself, but I'm going to go ahead and
Open the code editor for this routine.
So some of this may look a little bit familiar.
We've got our tag declarations. We've got tag types and definitions as well.
We've got our instructions Etc. One thing to note here is that this is not structured
text. As you are accustomed to using in studio 5000 logix
designer instead. It's a domain specific language for the FactoryTalk design studio
environment. The one note to make here is regarding other
programming languages.
You may have noticed that you've only seen ladder
ladder logic so far. That's because at present
that's what's available in Design Studio, but as we continue to build out a build
functionality into the environment structured text
sequential function charts and function block diagrams will also be added
now personally. I like to use the ladder Editor to write.
My code because I like to see things graphically,
but you can also write your code here in the code editor and a lot of our early adopters
of FactoryTalk design studio and even some of my own colleagues, especially those with a
software development background prefer the code editor because they work faster in the
environment. So the nice thing about design studio is that you can code in either the
ladder editor or the code editor and the changes are bi-directional. Let's do a quick
demo to show you what I mean. Go ahead and here in the code editor.
I'm going to add a simple run of code.
And just like you would you would expect from a text editor. I'm gonna see some of these
red underscores here. It's telling me that there's a problem
with whatever I've created and like you veterans are probably going to realize it's
because I'm not referencing and tag, but you'll also notice down here in the
output pain that the errors are identified for you. So it calls that out for you. So,
you know what to go and address now and let's go take a look at
the ladder editor again we added Very simple running of code here
and you can see here that it is automatically rendered
graphically. Similarly. I can go ahead and define tags for
this here. And the code editor will be updated with the line of code itself
as well as tag declarations.
Aside from the code editor being a productivity in a blur. It's also about
supporting granular Version Control. If you think about a more standard controller
project, it's one giant file with all your project content in it.
So it's hard to get really granular on comparing
two different versions with design studio the text bag
elements that make up the project allow you to look at each
individual part of the project and say hey did this change
and if it changed who The change in what exactly is different?
Let's take a look at how that works. Now the Version Control capabilities in Design
Studio are a great not only for the individual user,
but it's also great for collaborating with a team
for now. I want to focus on the benefits for an individual user
a few minutes ago. I added a ring of code to one of the smart
object definitions in the library, but imagine if you've been working on your
code for hours and hours and hadn't Committed any of those changes
again? If you're not familiar with a commit you can think of it like saving a snapshot of
a known good State now, we're constantly saving in the
background and design studio. So you don't have to worry about losing your uncommitted
updates. In fact, you can go back and take a look at your project history and get details
on what changes have been made if we take a look at the project history.
Right here. You'll see that we have a log file providing
dates descriptions person affiliated with those commits.
And all of that is captured here for you
in this shared project. We can also see uncommitted changes logged as well. Which
your which I'm hovering over right now. So let's go ahead and double click on this
and see what changes I made so I can decide if I'm ready to commit these changes or not.
Okay, so As you can see comparison of the last committed State appears alongside those
uncommitted changes. You can see here on the right hand side where
I added that simple ring of code and then you'll also notice that this comparison like
I mentioned during the presentation is text based.
But again, we're also working on a graphical representation as well.
So this is just an example of what that comparison allows you to do for an individual
user
where you can come in here and And of see what you've been working on
not only through all the commits that you've done through a particular day, but also see
those uncommitted changes. So let's go ahead and exit out of here and
commit this change.
I made to the project. Once the commit has been completed. I can go
ahead and push that update to the shared repository.
So other collaborators can access the updates that made
so let's go ahead and do that now. So I'm going to go ahead and press this commit
button. You can see that it is not grayed out anymore. Now that I have made changes
in the project. So I'm going to say I added
a wrong OF code.
Richard want to be more details and I'm going to go ahead and commit that
change.
Okay. So now that that change has been committed. You see that now
the push button up here in the Version
Control area has a has a badge on it
saying hey, you've got a committed change but you haven't pushed it up to the shared
repository. So let's go ahead and do that now to make it
available to other users who might be in this project and might want to see the changes
that you've made.
Okay, so we have gone ahead and push that information up to our
shared repository and we're going to come back to this shortly by looking at our other
user and seeing that those changes are available for them to pull down from the
cloud. In the meantime. Let's go ahead and talk about code allocation.
Okay. So on the topic of code allocation remember back in my system
explorer was Not my system logically without worrying
about the hardware that would be used to execute the code.
I don't have any controllers that are defined here. So what that means is that I need to
tell the code where it's going to execute.
So that's handled by this process called allocation
in my system model. I can select some modular code in the form of a smart object and then
we can go to the properties Pane and allocate that code to a controller.
So if I select on the SIP 100 smart object and I go over to the control
to the property pane you can see that it is
scheduled to be executed by the Sip 100 underscore
CLX controller. Now if you take a look at
the WDS 200 smart object here,
we click on it and we go back to the properties pane.
We can see that there's no controller that's scheduled to execute this
code. So let's go ahead and allocate this code. You
the SIP 104 score cm x controller?
I'm going to accept that and we're going to schedule it to run in the
default task. And now if we go to the execution pain
and we look at the cmx controller, you can see that that code is now
associated with the default task in the in the Compactlogix controller.
So that's how I go from The Logical world into the execution view by using this
process of allocation.
Okay, remember earlier, we push them changes to a shared repository.
And remember it was in the Sip 100 smart object
in this Outlet valve main routine recall that we had this
first run that I added here again, the tag still need to be declared, but I went ahead
and committed that change and I pushed it to the shared repository.
So what we're going to be doing. Is we're going to go and take a look at
the other user that's logged into this project and see how it looks on their side.
So now we're looking at the screen side by side like we were at the beginning of our
demonstration where I was making changes in the version of
the local version of the project on the left and then we had this user over here that
we're collaborating with and we're showing their screen here on the right now, you'll
notice that that the collaborators local version of this
product the status indicator down here at the lower right
now indicates that there are remote changes available.
So this is the one of the nice things that we built into the environment so that our users
can have a quick look as to the status of their local project in comparison
to the project that's available in the shared repository
another nice thing that we built into the version control system is the ability to pull
any shared updates to your local project with just one click of a button.
So we're going to go ahead and we're going to pull
down any Is that are available by clicking this
button? And while this is working any changes that were that are available in
the shared repository?
Like I said are being pulled into the local project and merged automatically. So there's
nothing else you need to do to be synced with the shared project. And the other nice thing
that you can do is as we showed earlier in the demo, you can go and do some comparisons
as to what is changed by looking at the project history.
Now you can see in the left user that the project is
synchronized with what's available in the shared repository
as is the user on the right. So if we go and take a look at the change that we made here
we double click on the main routine here. You can see over here on the left. This is
this is where the we added the wrong of code and you can see that it's available here now
on the right hand side as well. So what we're going to do now is we're going
to go ahead and Back into the presentation and we're going to
wrap things up. So far we talked about what FactoryTalk
design studio is and where it lives in our ecosystem and we covered some of the key
topics that make it a modern multi-user and multi controller design
environment. I'm not going to read this slide, but the key
things to remember here are that design studio is bringing modern software
development work flows into the Industrial Automation space and allowing multiple people
to seamlessly collaborate at the same time and supporting a multi controller environment
that allows Shooters to design a whole system.
Now one thing I want to touch on before we close out is that FactoryTalk design studio
is foundational and while we are continuing to build in new features and functionality.
We do have partnership with Studio 5000 Logix designer here at the
beginning. So when you're using the product today,
you'll start that design experience in the factory talk Design Studio
environment in the cloud. Then you'll convert your
project to a studio 5000 Logix designer file and then download it to your controller from
there. The reason for this is that we're still
working on that technology to deliver secure Cloud to controller communication.
So for now using logic designer to communicate with the controller and
ultimately be able to deliver that project dramatically. He says the risk of a version
one product. However, using Logix designer to deploy the project
will not always be the case. So in the future, we'll be deploying to the
controller via an edge device or remote access for VPN technology. So be looking for
that in one of our upcoming updates.
Speaking of updates one of the best things about delivering Design Studio as a SAS based
product is that we'll be able to frequently iterate on it.
In fact, we have an update coming just before automation Fair this year. So when you try
Design Studio remember, that's the development cycle isn't like a typical
on-prem software product where you expect to see a new release once a year
instead our feature set will grow quickly and with an update that's usually on a quarterly
basis. Lastly I'll just share that we are really
excited about where we are with this product with all those foundational pieces in place
for us to continue building on in the future. In fact, we're so excited that we're
currently offering FactoryTalk Design Studio at no cost.
You may not be ready to fully adopt this product, but we invite you to try it on your
own so you can see what we're working on in the design space. So I encourage you to visit
our website to gain access to the FactoryTalk. Talk Design Studio environment
or simply to learn more. Thanks so much for joining us today.