Chill, sit back and relax
Still trying to get familiar with PLC programming (using OpenPLC), I started with some examples:
Ladder Diagram on OpenPLC (Arduino Uno as the device)
Some introductions about basic syntax and examples are on wikipedia, and here's an example project in OpenPLC editor, which is outputting a line of text through the serial port at the same frequence of LED blink.t
This is how the LD program looks like:
Blink LD program
There are mainly 3 parts.
Part 1: timer + relay
This part defines the interval / frequency of LED blink. On the left there is an rung input ( or "checkercontact" in ladder diagrams) —[ ]— , it's taking the on-board LED's status as an input. TON0 and TOF0 are timer relays, what they do is to generate a high of low voltage output at the Q end according to the preset time duration.
rising edge enable PrintMSG
This part is using the rising edge of the LED pin to enable the PrintMSG function,
Providing string literal to the PrintMSG function
And eventually the message printing process is an arithmetic operation called MOVE , what it does is to copy the string literal from in pin to an external variable called SerialMSG on the OUT pin.
It still looks a bit confusing at this point, but there's also the Arduino side of the program:
//////////////////////////////// sketch section ////////////////////////////////
// This is the Arduino side of the project. The functions sketch_setup() and
// sketch_loop() provide the same functionality of the setup() and loop()
// functions of a regular Arduino sketch. On top of this code editor there is a
// variable table. You can add variables there that are shared between the
// arduino code and the PLC code. Since they are shared, you can, for example,
// read a sensor on the arduino sketch and use the reading in a PLC program.
// On the PLC side you must declare the same variable with the class "external"
// before being able to use it in your program.
// This Arduino sketch implementation is compatible with virtually every library
// or code you can possibly run on the regular Arduino IDE. You can create your
// own functions and also #include external libraries (as long as they are also
// installed on your Arduino IDE). The only catch is that your sketch_loop()
// function cannot block (long while loop or delays), or else your PLC code will
// block as well.
// Notes about this particular demo: Since this demo uses the serial port, you
// cannot enable Modbus Serial on your project, otherwise it will conflict with
// the messages being printed from this sketch. Also, this sketch shares a
// STRING with the PLC side. This is not a regular c-string, it is an IEC 61131
// STRING. Variables shared between the PLC and Arduino sketch are always IEC
// 61131 variables. For normal datatypes like INT, REAL, DINT, etc, there are
// direct equivalents in C (int16_t, float and int32_t respectively), so you
// shouldn't have any problems with those. An IEC STRING however is a more
// complex structure. You can typecast an IEC STRING into a c-string by using
// (char *)STRING.body as shown in the example below.
void sketch_setup()
{
Serial.begin(115200);
Serial.println("Hello World! I'm starting now...");
}
void sketch_loop()
{
if (PrintMSG)
{
Serial.println((char *)SerialMSG.body);
}
}
In this case, it's using the variables ( PrintMSG and SerialMSG ) modified in the ladder diagram in the sketch_loop function.
The output files of OpenPLC compiling process
When the program is being build, there would be some .obj and lib files generated:
CodeBlock Loading...
And actually the Arduino code in the previous section is in CFile_0.c:
CodeBlock Loading...
And the Ladder Diagram was translated into C files first, it's in a file called POUS.c:
CodeBlock Loading...
The ARDUINOPRINT_body__() contains the corresponding ladder diagram operations.
Problems
Is the compiled .so library files able to be executed on actual devices? Is it executed well in local simulator / development runtime environment?
How exactly is the compilation process executed? Is it possible to expose some internal variables or input to external entities? To what degree is the whole program configurable?
What are the possible limits for PLC programs ( if the developers want to create FMUs for these programs )? For example if some variables are supposed to be accessable by external entities rather than being private withing the FMU, would there be a guideline / to-do / not-to-do list for for the PLC programs?
Next Steps
- Try to run the example project on simulator, just to make sure it works.
- Check about different examples, including different languages in IEC 61131-3 and examples that are supposed to run on other PLC devices, pay attention to whether or not there are differences in generated C code.