0:03
Good morning everyone, thanks for joining us on this webinar for getting started with Cscape 10 in Canvas. Today’s webinar is longer than those previous so it will run over time today.
0:15
So if that is an issue for you it will be uploaded to the website on the YouTube after this webinar so you can catch it up there if you cannot stick around today for the end of it.
0:27
But we’ll get going and if you have questions just put them in and we’ll get through them at the end.
0:30
Hello and welcome to today’s webinar.
0:33
Today we will look at how to get started with Cscape 10 and Canvas. Let’s look at our agenda for today.
0:39
We will start with a quick introduction to Canvas, our latest and most advanced all-in-one controller line.
0:45
We will then show you how to set up Cscape 10, make a connection between your computer and Canvas and configure the Canvas hardware.
0:51
We will also do some logic programming, focus on IEC and finally do some screen configuration.
0:57
There will be demonstrations throughout and we will finish with a Q &A session.
1:01
First, let’s compare the Canvas and the Micro OCS controller product lines.
1:06
The Micro OCS is our entry-level all-in-one controller and is ideal for simple applications.
1:11
With Canvas, you get more advanced capabilities such as more memory, the capability to support larger programs and the ability to have faster scan rates.
1:20
You also have more graphic tools available to you and more protocols built-in.
1:24
The Micro OCS has the most popular protocols built in, whereas Canvas has these plus a lot more, including the IoT protocols such as MQTT Spark Plug, as well as the ability to remotely monitor and control your Canvas unit without any additional licensing requirements.
1:41
There are five different models within the Canvas product line.
1:44
They are available in four different screen sizes, including 3.5 inch, 4.3 inch, two different 7 inch models and a 10.1 inch each of these units have a really advanced graphic capabilities which we will discuss in more detail.
1:58
Like every Horner all-in-one controller every canvas model features a built-in PLC with lots of memory and the ability to support large programs.
2:06
You can select advanced ladder logic which we highlighted last week or you can select the full IEC 61131 program language suite which we will focus on today.
2:16
The canvas 7d and the some extra connectivity so they include an extra field bus port in the form of CAN as well as an extra ethernet port.
2:27
All canvas models are programmed using Cscape 10 which is our all-in-one software package. Next let’s look at the IO options for canvas.
2:36
All canvas units come with some built-in IO options as detailed here. This ranges from no built-in IO at all to 40 IO points.
2:44
most models support both digital I.O. and analog I.O.
2:48
as well as some advanced high-speed counting capability. If you want to have your I.O.
2:53
distributed on the machine or maybe fully located in the back plate you can also add OCS I.O. which is our expansion I.O. system.
3:02
In that scenario when you add OCS I.O. you could potentially add hundreds of I.O. points for a really large I.O.
3:09
because Canvas has a horsepower to support that.
3:13
Another thing that separates Canvas from our other product lines is the advanced graphic engine including newer and more refined objects and more advanced capabilities with resigned trend, alarm and recipe features.
3:27
Canvas offers a lot of protocol capabilities for communications whether it’s industrial protocol or IIoT protocols.
3:35
Every protocol listed here and every protocol that canvas supports is all built in at the factory so there is no need for field licensing or one-time upgrades or anything required and like some of our other product lines there is some variability between how many serial ports for instance or how many cam ports or ethernet ports are available on each model but this is detailed on the screen here.
4:00
For our demonstration we will start by quickly looking at how to get set up with Cscape 10 So once you have downloaded the install from our website and created an account, then you can download the software and run the install program.
4:14
Once you have done this, you will be asked to login using the same login credentials that you created when you set up your account.
4:21
If you want to skip this login step, the next time you start up Cscape, then you can select keep me logged in button.
4:29
So now we are logged in, next we need to choose what type of logic we want to use in programming.
4:34
To set this we will go select the seascape icon in the top left hand corner and select settings and from here you can take the box for whichever logic you prefer.
4:45
If you are new to Horner and you are not sure which logic you are going to use we would suggest for new programs that either support variable based advanced ladder or IEC and that you can check them both so you have the ability to select which one you prefer every you open a new project.
5:04
We also recommend that you do not select enhance IEC default because this is only supported by canvas instead we recommended that you just select this manually anytime you start a new project that is using canvas.
5:18
If you use both canvas and IEC all the time then you might choose to enable this now instead.
5:24
We will skip over to set up your desktop in Cscape as we covered this in last weeks webinar.
5:30
So now we will go ahead and create a new file and this is where we have choices based on that setting that we just reviewed.
5:37
For our demonstration we will use IEC 61131 and select OK.
5:44
So now we have created a new program, the next thing we would need to do is establish a connection with the controller which we will quickly review now.
5:53
You have a few different options for the physical connection between your computer and canvas similar to micro OCS However with canvas we recommend that you use ethernet as your connectivity from your computer to your canvas This is because we can download larger files quickly over ethernet So downloads do not take as much as they would over USB If you would prefer to program using USB then that option is also available to you and most canvas models still feature USB Mini-B as shown on the screen.
6:28
Horner offers a cable that you could use between your computer and that type of connection.
6:33
The Canvas 10D model also features USB-C so in that scenario you would use that form of connectivity.
6:40
We also have a few different programming cables available for connecting to USB-C on a Canvas 10D as shown on the screen.
6:48
Now let’s look at to establish that connection between your computer and canvas in seascape.
6:55
As we can see in the lower right hand corner here we do not have communications yet and because this is canvas we will use ethernet to communicate with it.
7:04
Again we could also use USB but it is not as fast.
7:08
The first step is to make sure the ethernet address of the canvas unit is compatible with our local LAN so we will switch to our bench setup and make sure that this setup the way we want.
7:19
In your case you will probably have the default program that is loaded in your unit from the factory if you just opened it up.
7:27
Here we have a program in our unit that we use for demonstrating USB cameras with canvas.
7:33
So first we need to pull up the system menu to access ethernet settings and we can do this by touching the upper right hand corner as we can see the system button has appeared and if you are familiar with the menu system in the traditional corner controllers you will notice it is quite different with Canvas.
7:52
Next we will select Network and then LAN and we have a few different things we can do here.
7:59
We are using a Canvas 10D, it has two LAN ports and we are connected to LAN 1.
8:05
So one thing we could do is we could turn on the DHCP and let our local network assign the address for us.
8:13
Instead of doing this we will type in a fixed address for IP address 1, since LAN 1 is what we are connected to, we will select IP address 1 and we will type in the new address, which is 192.168.0.253, so we have successfully changed that.
8:34
And everything else is perfectly fine in terms of the netmask and the gateway.
8:39
Now we will exit out of our menu system here and we will return to seascape.
8:45
Next, we will want to select the connection wizard from the ribbon toolbox and we will choose to connect over ethernet.
8:53
Next, we want to make sure that this IP address matches the one we have just configured canvas for.
8:59
So once we have done this, we will select finish.
9:03
Once we have our LAN 1 cable plugged in, we will wait a few seconds and then in the bottom right hand corner of our screen we can see that we are now locally air connected to address 253 which is our default CAN address on the unit.
9:20
All OCS units shipped from the factory have a default CAN address of 253 so our local address is 253.
9:29
Our target which we want to talk to is also 253 and IDL or stop mode is the mode that our controller is currently in.
9:38
So now that we have our connection set up, we will now take a look at our hardware configuration.
9:44
Once we do this, we notice that this particular controller does not match our setup.
9:50
This is because when we first started up Cscape, we did not have a connection with OCS controller.
9:56
So Cscape 10 picked the default controller, which happens to be an Excel 4.
10:02
To switch our canvas configuration, we need to select auto config so that the correct controller shows up once we are physically connected.
10:11
Next we will look at our LAN 1 configuration and we want to hardcode the proper IP address so that when we do a download it assigns the proper IP address to it because if we did not change this to match what it is supposed to be then when we did a download it will change it to the improper address and we would lose communication.
10:32
So we will configure all of these here and we will type in the DNS server here.
10:39
You could use the same address as your gateway if that is how your system is set up.
10:44
We will use one of the standard Google DNS here which is 8 8 8 8. So the key part here is the IP address and the net mask.
10:55
So we need to make sure we have these configured properly.
10:59
So now we have our connection established and our local target set and we are not in run mode.
11:05
Next to this we can also see the model we are talking to is equal but the program is not equal as we have not set up a program yet.
11:14
Our next step is to finish the hardware configuration.
11:19
So we will go back to our hardware configuration by selecting it in the ribbon toolbox.
11:24
We have already set the LAN address to its proper Next, what we would typically do is we would go into local IO and configure the local IO.
11:36
However, our particular canvas unit for our demonstration does not have any built-in IO.
11:43
Let’s temporarily change to a model that does have built-in IO.
11:47
Let’s say model 6 and let’s demonstrate how you would configure that.
11:53
And then we will go back in and get rid of that configuration because it does not match what we have on the bench.
11:59
So if we had a model 6 on the IO side that has a 6 analog in and 4 analog out, so we can go to localio config module setup and then we have our four different types of IO that we can configure.
12:15
These are digital input, digital output, analog inputs and analog outputs which we will do now.
12:23
On the digital input side it is almost always positive logic and it applies to all the inputs. This is for the model 6.
12:32
If you have a slightly different model of IO you will have slightly different choices.
12:38
High speed counter IO mapping where all the high speed counter IO is mapped. It has a default here.
12:45
We will just leave that alone for as we do not need any high speed counting but if we did this would be the mapping we would use and this is where we would set up between two counter mode and four counter mode and we would also have the ability to set up some more filtering on high speed counter side as well as set up what we want the counters to do.
13:09
To totalize, to frequent count, to measure pulse widths for quadrature That’s the input setup.
13:17
If you do not have any high speed counting going on, it is just a matter of selecting between positive logic and negative logic.
13:26
On the digital output side, this particular unit has 12 outputs.
13:31
The first two could be used for some higher speed options, like a PWM signal, where you vary the duty cycle, or the frequency of an output pulse train.
13:43
It could also be used for firing an output or having that output fire based on an encoder position.
13:52
For instance, most of the time if you do not have any high speed outputs then it is going to be configured for normal.
14:00
You can also come down here and make the outputs either hold their state or be on when they are in stop mode or when the controller is in stop mode.
14:09
Most of the time you are going to leave that alone as well.
14:13
On the analog input aside, this is something you are probably going to need to configure so by default on the model 6 all the analog inputs are disabled.
14:24
So let’s say we have a PT100 RTD on our first 4 channels so let’s go ahead and select that and then let’s say that we have 4 to 20 milliamp input on the next 2 channels and then this our filtering.
14:40
That can be a value between 0 and 7 to give us a balance between quick respond and stable signal. So 0 to 7 is the range. We would usually start with a 3 here.
14:51
We are going to leave it in degrees C as our unit.
14:55
We will hit ok and then on the analog output side something similar.
15:00
You have got 4 analog inputs to do with the first 2 which are 4 to 20 and the second two which are 0 to 10.
15:08
When we are going into stop mode by default they are going to hold their value, let’s say we want them just to go to 0 instead or go to the value of 0 which is generally going to be 0 to 4 milliamps or 0 volts.
15:23
Depending on the format, this is our hardware configuration and now we have configured our canvas unit with built-in IO.
15:31
Now, this step, we are going to go back and undo because we do not have a canvas unit with model 6 IO.
15:37
We have a canvas unit with no built-in IO.
15:40
We are going to change this back to model 0.
15:43
So that is the step you would not take if you have built-in IO.
15:47
You just configure it.
15:48
We are back to have an equal model, which we should.
15:51
Our program’s not equal because we have not done any programming yet.
15:56
Next step is to start programming.
15:58
We have previously created this new project for IEC.
16:02
Now let’s go ahead and start adding some IEC logic.
16:06
We are going to go over here to the project navigator.
16:09
Before we look at this, let’s first do a quick tour here.
16:13
This is the project navigator, which is one of the ways we can navigate all the different elements of the program.
16:20
This is our program variable list divided between global variables.
16:24
and there are some pre-established at the factory retained variables, there is none here.
16:30
Then those are the only two groups that are established by default of variables.
16:34
Over here we have our project toolbox which will populate with different programming functions.
16:40
Let’s head back over to the project navigator under control.
16:44
Let’s expand that and then under logic modules we have the main loop modules, subroutine modules and new DFB modules that we are going to start adding here.
16:55
We are going to start with the main loop model, we are going to highlight that and right click and under the new logic block we are going to select the specific language that we want to program this block in. Let’s go ahead and select a ladder logic block for this demonstration.
17:11
We are going to do a simple ladder logic configuration, once we have added that we can rename it. Let’s go ahead and give this a name.
17:20
We are going to do some simple motor control here. Let’s call it motor control.
17:25
You will notice that we have a top on our desktop and this logic routine here.
17:30
If you had used the Horner Advanced Ladder before, you can see this does not look the same in terms of this particular ladder editor that is tied to the IEC. It is really easy to use.
17:41
Let’s get started and create a new run.
17:44
We highlight in the upper left hand corner, we press this first button here, which inserts a contact, then it does that, it automatically creates a new run.
17:53
Let’s do some simple motor control.
17:56
We are going to double click here and type in a variable name.
18:00
Now we are doing the variable naming on the fly.
18:03
We are going to call this start push button.
18:06
Now this push button is physically wired to an input, we need to map it.
18:10
Lets say it is wired to the first digital input we are going to type in present i1 and we have our start push button.
18:19
Lets say our motor is what we have here as our coil.
18:23
We are going to double click and we will type this as motor run.
18:26
If it is connected to a physical real world output we need to map it.
18:31
Here it is, lets say it is the first output that would be present q1 digital outputs are queue in the Horner mapping scheme.
18:41
Now we are going to need a stop button here.
18:43
We need it between these two so if we highlight here we would press this button which inserts a contact after and let’s say this is our stop push button.
18:53
We are creating these variables on the fly, let’s say a real world input%i5 is what this one is physically wired to.
19:02
Then the last thing we would need to do for this simple start stop circuit is a seal around start push button.
19:09
Now we will highlight this contact and press insert parallel contact.
19:13
So if we double click here then we are going to make this the motor run contact.
19:18
Now we could just type in the motor and it will auto populate or we can just browse our tags here until we find the motor run and double click on it. This is a simple start stop circuit. Let’s go ahead and add a timer.
19:32
Just so you can see how timers work we will go ahead and time how long our motor runs.
19:37
contact is running to do that we are going to create a new run we highlight here press the insert contact button and it will add run let’s say we want to time the motor run to do that we want to insert a timer in between here so we want to find the insert function block after button which we will go here and insert a generic function block here now we can double click here and select our timer counter there.
20:07
The other thing we could do is we could go over here to the toolbox and scroll under timers and counters and find the on timer that we want.
20:16
If we want an on timer with 100 milliseconds resolution we can select that and click and drag it over to the top of the one we previously created. And now we have our timer that we have inserted.
20:28
We are going to expand it so we can read this better. We will double click here.
20:33
We need name this timer we are going to call this the motor run timer we do not need to map it to anything it is just an internal timer so we say yes and then we need to assign a preset value this could be a variable or a constant we are going to make it a constant five seconds so that it would be a count of 50 and 10 of a second that’s five seconds and then this is our accumulator which we need to line here. We are going to call this motor run time.
21:06
This is just a variable that is an integer internal. We do not need to map it to anything.
21:12
We are going to go here and then if we are going to use this coil, when this timer expires we could just go ahead and do that. We will go ahead and give this a name.
21:23
We will call this motor run 5 seconds we were only going to be using the timer and we did not really care about the coil we do not have to send anything to the coil now once we have done a few runs here you get there is a button down here called align coils so press that and now things are the coils are aligned that will help everything to be lined up nice and neat that is a simple ladder routine that we added here but one of the is that we can also do structured text and other languages.
22:01
Let’s go ahead and add a structured text routine as well.
22:05
We are going to go back under the main loop modules and click on or select a new logic block.
22:11
This time, this time let’s select structured text and let’s say that this structured text block we are just going to use it for some analog math.
22:22
Let’s say that is what we are going to it for so we have given it a name analog math we now have a new tab that has shown up called analog math with just an open workspace here that we can start typing in structured text let’s go ahead and comment here this routine is used for analog math let’s go ahead and do some simple math here now we are going to go ahead and create ahead of time variables we are going to go down here under the global variables, we could also create retained variables.
22:55
Global variables are always reached at zero on PowerUp.
22:59
Retained variables retain their value on PowerUp.
23:02
We are going to go under global variables and we will see there, there are some that have already been established at the factory and the ones that we added already on the fly.
23:13
They have been added to this list.
23:15
We are going to right click within global variables hit add variables and then we are going to start creating variables let’s create one for analog input coming in let’s say it’s temperature temp raw AI next let’s add one let’s say that this is a real value of that temp raw AI let’s make the next one temp raw real now one important step that we did not do when we created this one.
23:46
You need to set the type to the raw AI coming in from the analog input is an integer value. And then we are going to convert that to a real value with this variable.
23:58
Let’s say we have a couple more variables.
24:00
Let’s add another variable that is temp degrees C. We are going to convert our raw value to degrees C and make that is going to be a real.
24:10
Then let’s add another one that is tempDagF, these are just examples and we will also make sure to add the type of variable.
24:20
Now if we had multiple analog inputs and we were going to be doing the similar processing on all of them.
24:27
We could make these variables that we have created into arrays by adding dimension here.
24:34
We have created our variables ahead of time, now let’s go ahead and do a little bit of To do the simple math that we are going to do, we are going to find conversion operations that we want to convert our raw value, coming into a real value, so we need to convert to a real function.
24:53
So we are going to go ahead and drag that here into our AnyToReal function.
24:58
We are going to add a space here, because we have to type in front of it.
25:04
If we kind of hover over that it will eventually show us if we do it properly.
25:09
Let’s make that space out and do it again. It will eventually show us a syntax.
25:15
Basically our input is with the variable we want to convert and our output is the real variable.
25:22
Let’s go back here and follow this proper format. So the variable that we are converting is to temp raw real.
25:29
So, we should be able to drag this here.
25:33
There we go temp raw real equals that’s our assignment statement.
25:38
Any to real and then in parenthesis we can either drag or just start typing.
25:44
Is temp raw ai and then we can not forget our semicolon at the end.
25:49
We have converted our raw ai to a real value.
25:53
Now we need to convert degrees C.
25:56
Let’s do that next the way we are going to do that.
25:58
We are going to drag this here, 10 degrees C equals this value here.
26:04
We are going to type in times 20, that is because with most Horner built in analog inputs, there are high resolution that have temperature supports like RTDS and thermocouples are usually in 20 degrees C increments. This is the kind of value or the format those are in.
26:23
So we have created a variable for degrees Celsius by just multiplying by 20 and if we want to create a degrees celsius variable we are going to drag here or we could just type it in this one is our standard formula for conversion and that is going to be 10 degrees celsius times 1.8 plus 32 and we do not need to have any parenthesis here because we are going to do a multiplication first which is what we want and then we are going to add 32 and we cannot forget our semicolon. We have created a simple little routine here.
27:00
Let’s double click and make sure that we have not got any syntax errors.
27:05
We are going to do that by pressing the error check button.
27:08
It says non-fatal compilation errors are found. Do you want to continue? We will say no.
27:15
These non-fatal errors are the ones we have not created on the screen yet.
27:19
It is just a warning that says we have not got any screens.
27:23
The screens are empty as we have not created any yet.
27:27
Let’s go ahead and close that down.
27:29
We have successfully created a motor routine in ladder logic here.
27:33
We have successfully created a structure text routine here.
27:37
And now the last thing is to show you how to add a comment here.
27:41
We are going to highlight where we want the comment to go.
27:44
Then we are going to hit insert comment line button, double click here, and just add the comment.
27:51
So we are going to add a simple comment.
27:53
This is the start stop logic for the motor and we will hit the little check mark and have insert and we have inserted a comment.
28:02
For our structured text we could have just clicked over here as well. You can just add comments here, convert integers into real variables.
28:11
We will quickly learn how we can save our program in Cscape 10.
28:16
By default our program has an untitled name such as Untitled 1, Untitled 2 and so on.
28:24
To give our program a name we need to save our program which we can do by selecting the seascape icon in the top left hand corner and selecting save.
28:35
We could have also selected save as here.
28:37
Once we select save as we have an untitled program it will prompt us to name our program which we will call Motor Control, Demo IEC and select save.
28:48
So now we have it saved and renamed our program.
28:52
Next let’s start building a screen.
28:54
To do this we are going to go back to the project navigator under user interface and we are going to expand that and we are going to go to the main screen, right click and say new screen.
29:07
It creates a new screen by default.
29:10
Screen 1, we are going to give it a different name, let’s go ahead and call this motor control and once we do this Cscape adds a screen editing area.
29:21
Here a new tab with the name of the screen and the number of screen followed by a screen editing area.
29:28
Now it is zoomed in a little bit further than we would like. We are using a 10 inch model.
29:34
Lets go here and we are going to back it up a bit and by default we have this happen to be a 10.1 inch screen area with great systems. Now lets do a couple of things.
29:45
First of all we are going to right click and we are going to go to grid setting.
29:50
We are going to get rid of the primary grid that is the big blocks and we are just going to snap to a smaller grid which is the dots.
29:58
So now we have kind of cleaned things up the way we want from the grid standpoint so we will still line things up and one of the things you can do in canvas is you can set up a background.
30:09
If you have a specific background in your mind you can set up a background on your The next thing we are going to do is right click and hit set background so let’s go take a look at the available patterns and let’s select a pattern.
30:24
We are going to go ahead and select a pattern we are going to have it maintain the aspect ratio of the pattern and then just clip it as needed.
30:33
We will hit select pattern now and then we get a menu of all the standard patterns are available, lets do this brushed aluminium.
30:42
Now if we want to add a tint to that, a different colour to it, maybe tinted blue or tinted green, we could do that as well.
30:49
But for now we are just going to leave it as it is in its default form.
30:53
Select ok and then as soon as we click on the screen, it goes from being dropped here to taking up the entire screen.
31:00
So this is what the brushed aluminium pattern is going to look like on our screen.
31:05
Lets we want to just quickly go ahead show a push button and a pilot light for the motor let’s go ahead and do that we are going to go ahead and under live graphic data we are going to expand that and we are going to select a lamp or an indicator because we want an LED or a pilot light that shows when the motor is running so we are going to click on that and then we are going to click and drag to size a pilot light now the default is this light bulb we are going to select a different indicator.
31:35
Let’s just go ahead and do something fairly straightforward.
31:39
Let’s select this particular indicator and then let’s give it a legend plate.
31:43
So under legend plate properties, we are going to go ahead and give it a border.
31:48
If we want to hit legend, and then we will just type this in, we are going to hit run.
31:53
We could name this whatever we want.
31:55
We should probably make this a little bigger.
31:57
Now let’s make it thirsty.
31:59
Next, we will set the colors the way we want.
32:01
Let’s say one is bright green but let’s make it dark green and we can go ahead and leave the gradient on there.
32:08
We do not have to use the gradient but we will go ahead and leave that there and then we ultimately need to tie this to a variable. We want to tie it to motor run.
32:17
Let’s find that variable or we could have just typed it in and hit ok.
32:21
There is our run lead that is going to indicate when the motor is running or not.
32:26
Now let’s say we want to display how long the motor been running that motor timer value.
32:31
To do that there’s a couple of ways we can do it but we are going to go to live text data and we are going to pick a numeric data field and then we are going to click and size it the way we want and then double click on it to configure and this time we’re going to start by assigning a variable to it.
32:48
We do not have to do it that way but we are just going to start by assigning a variable to it.
32:52
So let’s find our motor run a time which is a variable that we want.
32:57
Now this is a 16 bit variable, we really should have selected that first but it is already selected.
33:03
If we had a 32 bit real variable we could have selected 32 bits there first.
33:09
We do not want an assigned decimal, we just want a decimal because this count of the timer is going to be numeric.
33:16
We are only counting up to 5 seconds which is the count of 50, so we do not need to show you all the different digits.
33:23
If we want to we can do that we can do one 2.1 to imply a decimal point so when the value is 30 0.3 is the way it will be shown on the screen even though the value is still 3 we are going to add engineering units here of an s for seconds we will make the font bigger let’s go ahead and make it a good size here 40 a bigger size that is not a writable data field we will uncheck that and let’s go down here to legend and changes to runtime and we will make the font a little bit bigger.
33:58
Let’s go ahead and leave that there on the background.
34:01
Let’s select a different background.
34:03
We will select a pattern here.
34:05
This time let’s select our brush on a menu.
34:07
Let’s select something a little different.
34:10
Let’s do this blue background here and we will hit okay again.
34:14
So now we have runtime.
34:15
If we want to start the motor by touching the screen, not just display it, we would want to add a push button or some sort of button.
34:23
So to do that, let’s do that here.
34:25
Let’s go ahead and collapse that and under touch object, let’s select the button slash switch.
34:32
We select it, click and drag it to size and then we will double click and let’s select our switch type first.
34:38
Under push button, we are going to go ahead and select this.
34:42
We will just use it as it is and then go back up here and select our variable, which we want to be our start push button.
34:49
we have two position monetary button and we are going to leave it like that.
34:54
Now with this particular button you do not have a built-in legend plate so you would need to add one of those.
35:00
We are going to size this a little bit and then we are going to add a legend plate in the form of just separate text object so we are going to go under fixed objects and text label and click and drag to size approximately and then we are going to call this the motor start and we are to give it a good size here and select OK.
35:20
So now we have a motor start button and we have a run lead and we have a run time.
35:25
Let’s say for example we assigned it to a start push button now that was a mistake. Why was that a mistake?
35:32
Well the start push button when we previously created that was wired to a fixed input so it is actually a physical button so if we are going to from the touch screen we need a parallel button here so we need to create a new variable not use an existing one so we are going to create a new variable and we are going to call it the start touch button or TB for touch button and this does not exist yet so when we type in a new variable it will ask us if we want to create it and we will say yes and because it is not wired anything there is no reason to map it and now we have a new variable called start TP that if we use it in our logic we can use it to start the motor so let’s go back to our motor control routine and add in a parallel contact to the motor run so we are going to click on here because that is the area we want to add the parallel contact and we are going and we are going to click on the insert parallel contact, which adds it here to the logic.
36:39
And now we want this to be our start TB.
36:42
So we are going to go ahead and type that in there, double click on here and then pick it from our list.
36:49
And there it is, start TB is what we want for this.
36:53
We have added a parallel contact, which is if we take a look at our screen, we will see the button is going to make that turn on.
37:01
Now we will also create a stop button so that we can stop it as well but instead of creating these separately let’s highlight these two objects right here and click copy right click and hit paste now let’s move those down here and let’s make this a stop button so we have double clicked on the text and then we need to go in here and create a variable and we are going to call that variable stop bt that is what we are going to call this it does not exist that is fine and we do not need to map it to anything.
37:34
Now we have added that to our screen we need to add that to our motor control routine.
37:39
We want to add an additional stop button but with start buttons you add them in parallel with stop buttons you add them in series.
37:48
So we have highlighted our current contact and add another contact.
37:52
Let’s say to the right let’s make this closed by hitting the space bar and then double click on it and select from our list. Stop touch button and now we have added an additional stop button.
38:06
We have fixed this by making these normally closed and having two of them in series.
38:12
We have added our additional push button to start it in parallel.
38:17
We are good to go.
38:18
Now one other thing let’s go ahead and show how we can display our temperature value in degrees Celsius.
38:25
So let’s go back to our motor control screen and let’s add a data field here that is going to show this temperature in degrees Celsius.
38:33
Let’s say for our temperature coming back in to our screen, let’s add a data field which is going to be a live text data.
38:41
It is going to be a numeric data field.
38:44
Let’s click and spread it out.
38:47
Double click on it.
38:49
Now the variable that we want to tie this to is a real variable and real variables are 32 bits so the first thing we have to do is change 16 bits to 32 bits this is a real variable coming in so let’s make a real and then let’s tie a variable to it and the variable we want is 10 degrees celsius so this is only showing 32 bit variables because as have we specified it 10 degrees celsius 32 bit this is just a readable value and then how do we want to display it now this is the floating point value so we can display however many decimal points that we want for any kind of real value we are going to go ahead and just show it if our biggest temperature is going to be a few hundred degrees then we make it one two three point one with one decimal place we can make this a Celsius for degrees Celsius.
39:48
We can make this font bigger and then for our legend we can just call this temperature. Let’s go ahead and go to the play style.
39:57
We will leave it as a round rectangle and then under the background let’s go ahead and do another pattern.
40:03
Let’s go ahead and select the same blue background again.
40:06
We have created another data field for displaying this temperature from our structured text routine.
40:12
So we have created a screen or we have also created some logic.
40:16
Next, we will look at how to download our program.
40:19
Before we do this, we will double click on the hardware config that our LAN one matches what we want since we are programming over internet.
40:28
This is to ensure that our IP address is not changed during our download.
40:33
So now that we have checked this and we have our communications established, we can start our download.
40:39
To do this, we will select download from the ribbon toolbar.
40:43
When we select this, it will let us know that the register of allocation between downloads and variables can change.
40:49
We will select OK and we will start to download.
40:53
Cscape does a quick error check and that everything is ok with our program.
40:58
Now we will do a smart load and we will compare what has changed with what needs to be downloaded.
41:03
Nearly everything has changed in this program compared to the one that is loaded in seascape currently.
41:10
So this may take a little while to complete, because it will download everything on this pass including the logic program, the hardware configuration and the graphics.
41:19
On this first download and on future downloads not as much will change and therefore less will need to be downloaded and the process will not take as long.
41:28
Once our program is finished downloading there is one last step we need to take that is to make sure that we are in run mode.
41:35
We started our demonstration not in run mode so now we will need to manually put it into run mode.
41:41
In your case your unit may have been in run mode and then you downloaded it and then it went back into run mode so if your program is in run mode to start with it will go into stop mode when the program is being downloaded and that puts the controller back into run mode.
41:57
If it starts in stop mode or ideal mode it also ends in ideal mode. So we have to manually start it.
42:04
There is an online programming mode with Canvas where you can do downloads without having to stop your program.
42:10
Available called Online Change but we will not be using this today.
42:14
Instead we will put the controller into run mode from our ribbon to a bear by selecting run under the home tab.
42:21
Now we are in run mode and we will look at this in our bench setup.
42:25
As we can see our program has been downloaded when we select the motor start button our run light turns on and our run timer starts going up and then stops when it reaches five seconds.
42:38
Our motor is still running so we will now stop our program again manually using stop button.
42:44
Our temperature is shown at zero degrees Celsius because we do not have any value coming in from IO so those values are zero.
42:52
If we had some real-world data coming in on analog input then this would change. Finally we will take a quick look at how to debug in.
43:01
There are a few ways we can go into debug mode.
43:04
For one we select the debug button from our taskbar at the top of the screen and this will take a few seconds.
43:11
When we do this, Cscape 10 is reading all the values and all the variables in the program.
43:16
If we switch to one of our logic routines we can see the status of every variable.
43:20
As we can see our runtime is zero, our motor is not running and we would pass our flow through the stop buttons if our start button and our seal were on.
43:31
Now we will start the motor so we pressed and released the start button as we can see reflected in our logic if we just adjust our screen we can also see our runtime and if we stop the motor by pressing the stop button on the screen then we are good to go.
43:48
While in debug mode if we looked our structured text routine we can see all the variable values here as well.
43:55
Once again we are getting zero here because we do not have any IO actually connected to that canvas unit. That concludes our webinar for today.
44:04
Thank you so much for listening and the Q &A session will begin shortly.
44:12
Okay apologies about that being a bit longer this morning.
44:16
We’ll get them more regular times again in the coming weeks.
44:24
The last thing I’m thinking of is a nice overview for you getting started with Cscape 10 in Canvas.
44:31
Yeah, there’s no questions there yet, but if you do have any, you can feel free to contact technical support.
44:37Okay, thank you all for joining.
