This isn't a particularly important question; I'm just a grad student in real-time research so I like learning about what gets used in practice. Thanks!
https://wiki.linuxfoundation.org/realtime/start
It contains patches to get latencies down and touches numerous subsystems of the kernel. Most importantly, interrupt handlers become preemptible. (Normally interrupts are executed in "atomic context", i.e. they cannot be preempted. This also means e.g. that you can't sleep in an interrupt handler because the timer interrupt is disregarded. With PREEMPT_RT_FULL, interrupts are executed in "process context", i.e. as normal kernel threads which can be interrupted.)
We use the kernel branch of the Foundation (which contains a ton of patches required for hardware support of the Raspberry Pi), cherry-pick the realtime patch set on top, then apply three custom patches, one is a fix to make the USB driver's interrupt handler preemptible. The result is this branch:
Yes, I see your point that a developer could just use a stock RPi to get started, and switch up to RevPi for production use. But this guy wants your sexy case in cardboard.
One of the reported issues with the Raspberry Pi is failure of the SD card if power is interrupted while the card is being written. Does your implementation overcome this problem?
Of course the eMMC is still based on flash, which has a limited lifetime. So we use a customized version of Raspbian which has swap disabled by default (can be enabled if you need it) and tunes the syslog configuration to reduce the amount of log data written. It's also possible to use a tmpfs-backed /var/log (can be enabled with a mouse click or a simple command). That way we try to prolong the lifetime of the eMMC as much as possible.
We've also been in talks with the Foundation about this and they have asserted that the eMMC is of good quality and should last for the typical lifetime of a PLC (which can be decades).
But noone is forcing you to use a specific software. You can use Python or even Bash. The input and output values are stored in a process image by an open source kernel driver (piControl) and you can access the process image through a char device. Just seek() to the value you're interested in and issue a read() or write().
If the question is about motion control of robots, our cycle time of 10-20 ms is probably too long as motion control usually requires < 1 ms.
If on the other hand the question is about human-robot collaboration safety, the product is likely unsuitable as this requires specially certified appliances.
If it's none of these two, it would be necessary to know more specifically what the setup is (fieldbus used, number of axes, etc) to come up with a realistic figure.
2. Why did Kunbus stop selling liquor? ;-)
2. I think that was a different company, I'll have to ask the CEO next time I see him.
2. Yes, sure, we just found it incredible that he used the Kunbus name and address for the imprint. Had a few laughs about it over there in Ostfildern. :-)
Upgrades to new releases can be performed either with an in-place "apt-get dist-upgrade" as is customary on Debian-derived distributions, or by creating a backup image of the eMMC, flashing the new image, then copying over any customized config files from the backup.
The German I/O module page has an animation which shows this in detail, it seems the English page is missing that for some reason:
The CSI and DSI pins are not accessible on external ports I'm afraid. I'm also not aware of plans to add modules which would make CSI/DSI available externally. In theory it's possible to open the case and attach wires to the pins which go to a connector external to the case and you could connect a CSI camera or DSI display there, however the result can hardly be considered "industrial". :-)
An alternative is to connect a USB camera.
The 4-core BCM2837 on the Compute Module 3 is beefy enough for image processing with OpenCV, in fact we're using OpenCV for our demos at expos. It may even be sufficient for video transcoding. One thing to be aware of though is that we're using a kernel with RT patches. Which means low latency, but also lower throughput. If you don't need low latencies but maximum throughput, it may be a good idea to use a kernel without RT patches. All the tooling to build a custom kernel is on GitHub.
I am actually working on a prototype of something similar- Pi, camera, small touchscreen, distance sensor and small number of IOs.
The two specific use cases for me: measure dimensions of parts hard to measure with other sensors and stopping conveyor when some parts end up in unexpected places.