I have a Codesys Project which becomes more and more complex.
Now I’m wondering if there is a python library that lets me do the programming part, I’m usually doing with Structured Text via Python?
Thank you
A
If you were using the Beckhoff platform which is very similar to Codesys I would have advised you to look into the ADS interface which helps interface PLC's with user space programs.
For Codesys there is also a proprietary interface called the PLC-Handler but it's not free of cost.
Since you have to pay one way or the other the approach I suggest is to buy the MQTT-Client for Codesys and write a Python-Client with one of the freely available libraries like the one of the eclipse foundatation: https://www.eclipse.org/paho/index.php?page=clients/python/index.php
The advantage of this approach is that once you've written the user space client you can interface with all PLC brands, since every major PLC brand offers an MQTT-Client library which you can use to write a small command and control PLC-Library for your PLC's.
So, I've been meaning to find an answer to this question for about 3 months now. I'm just a beginner to the world of FPGA and hardware programming in general. I've only built the NIOS and tried a few things using quartus and a DE10 standard FPGA (which I don't have access to anymore). So, all I know is that a bitstream or netlist is created to program an FPGA, which I can do from the programmer feature in quartus after the design is complete.
My problem here is, how does OpenVINO manage to program the FPGA while the code is written in python and may use several libraries. I've already ordered OpenVINO starter platform FPGA.. but I need to know how this works. I've only seen like 1 python to HDL synthesizer, which is MyHDL and it looked quite complicated.
OpenVINO FPGA depends on dlaplugin, Intel DLA architecture follows set of configuration methods, can be configured with Deep Learning Suite which is not provided as open source.
Intel FPGA runtime stack need to be installed to program an Intel FPGA.
aocl program device bitstream.aocx
after, dlaplugin helps to run application on FPGA
I have a WAGO PFC200 750-8206 and was wondering if I can write my control logic code in C/C++. I know that WAGO uses codesys runtime and codesys only supports IEC languages, but WAGO claims that their PLCs support C/C++ programs. What I am not sure about is if they mean C/C++ applications in Linux or actual control code running inside codeys?
copy/paste from WAGO:
"Alternatively, the runtime environment can also be completely created by its own “C/C++” programs, permitting access to both the internal bus, as well as MODBUS, CAN and PROFIBUS."
https://www.wago.com/global/embedded-linux
Wago provide an SDK that will permit you access to the IO. Use this link to apply for access to the SDK
I am fairly new .. I want to ask
If i can get the installed system drivers of any device/interface card in my Pc and use it in my own applications.
If i can then .. Can anyone tell me if i can use the sematic s7 installed MPI drivers for communication with the Siemens plc with my own application..
I want to use this with c#.net in windows environment
The first question needs more work: the drivers, once installed are already there. There is no concept of "getting" them. You can open a handle to installed drivers to perform various operations, if you know how, and the means to do so differs greatly between different types of drivers.
As for the second question: unless you either have source code or documentation of the driver in question, I doubt it would be possible. Of course, the simplest alternative is to obtain a library from the vendor to access the PLC from an application. The library will hide all the tricky parts of using the driver.
I wanted to learn .NET Microframework and found that there is (among others) Netduino which is somehow compatible with Arduino. Recently .NET Gadgeteer came to public. There was a lot of enthusiasm, so it looks like important step for .NET Microframework.
Is it possible to compare them somehow? I'm not sure for what tasks is better Netduino and for what tasks Gadgeteer. Or are they in fact completely different beasts?
I'm unable to read this from information available on home pages, because there are mostly marketing materials.
Netduino (and other HW boards, including GHI's FEZ products) are HW devices with an MicroProcessor running .NET Microframework - but in an form factor that resembles Ardunio, meaning you can plug other boards (or shields) on top of the mainboard to extend its functionality.
.NET Gadgeteer is something different:
.NET Gadgeteer Hardware
A .NET Gadgeteer system is composed of a mainboard containing an embedded processor and a variety of modules which connect to the mainboard through a simple plug-and-play interface. There are lots of .NET Gadgeteer modules available today: display, camera, networking, storage, input controls, and more modules are being designed all the time!
The .NET Gadgeteer mainboard's sockets are numbered, and each is labeled with one or more letters which indicate which modules can be plugged into it
CPU is more powerful than Netduino class of devices.
Gadgeteer runtime
Gadgeteer is 100% C# managed code so it is not tied to any firmware (C++ code). http://gadgeteer.codeplex.com/
It is an “Open socket-connections standard".
You can get a module from company x, another module from company y and use both on mainboard from company z, even if you didn't have design files. All will work together nicely. Of course someone may come up with an advanced model that requires special software but mostly modules will simply work.
You can even make your own modules to go on any mainboard...this is the beauty of gadgeteer.
Think of this as "arduino shield like" but better since there is no pin overlapping and you are not limited to couple shields before the board is too long to be usable. You could even take the gadgeteer socket standard and use it on a board that is not running NETMF at all , but you will lose all the nice software gadgeteer provides.
For details about the runtime check out the documents at Codeplex, http://gadgeteer.codeplex.com/releases/view/72208
For more information check out:
http://research.microsoft.com/en-us/projects/gadgeteer/default.aspx
http://channel9.msdn.com/coding4fun/blog/Along-came-a-spider-a-NET-Gadgeteer-FEZ-Spider
http://www.ghielectronics.com/catalog/product/297/
http://channel9.msdn.com/Blogs/Clint/NET-Gadgeteer
Netduino Go was recently released...supporting both Arduino Shield and Gadgeteer module pin compatibility. It also supports plug-and-play go!bus modules.
A few clarifications on Gadgeteer and Netduino:
Gadgeteer, from a hardware perspective, is a pin-assignment technology like Arduino Shields. There's a similar level of simplicity/complexity to it as with Arduino shields (i.e. overlapping pins, peripherals that go away on one socket when you plug in modules on another socket, fixed number of peripheral features, etc.) In contrast to Arduino, only a subset of Gadgeteer modules will work with a given Gadgeteer mainboard. But with Gadgeteer, you get multiple pin interfaces so there's less pin overlapping.
Netduino Go uses plug-and-play style modules. The go!bus protocol that Netduino Go uses is virtual I/O...so when you plug in a go!bus module it auto-enumerates and adds its features to the mainboard. Similar to how USB works on your computer. No overlapping pins or module limitations.
Netduino Go also has a compatibility mode where you can plug in Gadgeteer modules to up to two sockets. Like with other Gadgeteer-compatible boards, plugging in a module disables functionality on one or more other sockets.
Netduino Go has six times the code storage (1MB, 384KB for code), four times the speed (168MHz), and twice the RAM (100KB+) of Netduino Plus.
More info on Netduino Go:
http://forums.netduino.com/index.php?/topic/3867-introducing-netduino-go/
More info on Gadgeteer:
http://gadgeteer.codeplex.com/
Chris
Secret Labs LLC
Netduino is built with the open source hardware movement in mind and is compatible with existing Arduino shields while allowing you to use the .NET Micro framework to program it. This allows you to leverage existing experience with .NET on that platform instead of having to go through another language.
.NET Gadgeteer is a completely different take on the hardware with a specific set of hardware created for it that is modular and standardized.
Think Netduino as an Erector set and .NET Gadgeteer as Legos. You can build stuff with both of them but one is a bit more powerful if you want to apply what you have created to a broader set of problems.
Initial startup costs to get involved are also cheaper with Netduino.
See: http://www.i-programmer.info/news/91-hardware/2819-net-gadgeteer-an-alternative-to-arduino.html
Really the only downside to the Netduino Go is the current lack of networking as at end May 2012.
Chris has already said (elsewhere) that this is only weeks away, and when it ships I suspect the Go will be the go, as it were. It is to Gadgeteer as C# is to Java - more or less the same but done better with the benefit of hindsight. Looking around the forums I see other platforms with either uneven hardware compatibility or mediocre driver quality.
There's also a possibility of onboard RTC. Not a certainty, but you never know your luck in the big city.
Something Chris (and the Gadgeteer guys) don't take enough credit for is the computer-as-a-network approach Gadgeteer and Go both take. The network stack on a single CPU system like the NetduinoPlus can never perform like one that has dedicated CPU with its own buffer, and pushing the network stack onto its own board gets it out of your application code space. I suspect that the Go, running on a Cortex M3 with a supporting cast of Cortex M0s smoothly integrated by the crunchy goodness of baked in virtualisation, is going to feel like developing on a much larger machine.
Some things none of the prototyping boards do well are
Hardware watchdog reboot for hung application code
OTAU (over the air update)
You need both of those for release grade hardware, which I guess means rolling your own. Netduino Go and Gadgeteer expressly support the notion of roll your own modules.