Real-Time Computing - Science method

To clarify the relationships between ANNs and Reservoir Computing/Capsule Networks, you may have a look at:

Related question of interest on RG: https://www.researchgate.net/post/what_is_the_realitionship_between_deep_learning_methods_and_reservoir_computing_if_any

Dear Liming Yuan,

I think that the promising research directions in optimal control is in intelligent optimization advanced control.

Please see the following links.

A Feedback Optimal Control Algorithm with Optimal ... - MDPI

www.mdpi.com/2227-9717/5/1/10/pdf

Towards Optimal Power Management of Hybrid Electric ... - MDPI

https://www.mdpi.com/1996-1073/11/3/476/pdf

Best regards

You may check the fitting of the ETAP-RT to your demand.

The "real-time" aspect generally relates to the speed at which you can close the control loop. Depending on the application, this leads to different constraints and also different interpretations of the term "real time". E.g. for haptic control, generally, you'd need 10Hz for obtaining a good operator "feeling", whereas for video transmission, you'd probably need 25Hz.

YOLO, Faster R-CNN, and tensorbox.

Thank you Hilal. I've seen some references, and artifact removal is critical. Even with a reasonable bandpass filter there are remaining artifacts. This is discussed e.g. here:

"A Prototype of Reflection Pulse Oximeter Designed for Mobile Healthcare".

Did you process PPG signals? How did you remove or ignore the artifacts?

Thank you in advance!

Depends on the standard error you require from your experiment.

Anas Al-Nuaimi

I recommend you to follow this post, from Jay Rambhia, that uses the StereoSGBM algorithm.

I tried it a couple of days ago with great success with 2 ps3 eye cameras, in Linux:

Please note that before applying the StereoSGBM, you first need to calibrate and rectify both image cameras.

For the stereo calibration, follow this link:

If you need any help please ask me. Right now I am  deeply working in this area.

Best regards

João Martinho Moura 

This one is worth every penny:

It depends of course what exactly do you want to achive - if you want to just get informed how it is done or if you want to do some real development. In case you want to get your hands dirty a single book would not be enough ,but its still a very good start.

I don't have knowledge on ABS, but if you want to design such real-time system, from software point-of-view you may start with real-time OS (the free one like FreeRTOS, uC/OS (some), etc). Embedded Linux require MMU which not all the platforms have it.

My clarity is given below:

My works is make an efficient techniques for load balancing in cloud computing.

Mike, EMI-EMC is altogether has grown as a separate branch in design and PCB engineering. As Susan has stated, GROUND and POWER are not just limited to FEED the BABY but adequate GROUND TRACKS alternately laid between the PCB traces carrying these signals are the best practices. And yes, most of the PCB design software offer the Signal Integrity as an add-on module, the cost is however not within everybody's reach!

i think you should start with matlab.

See e.g. Negahdaripour, S. & B.K.P. Horn, “A Direct Method for Locating the Focus of Expansion,” Computer Vision, Graphics and Image Processing, Vol. 46, No. 3, June 1989, pp. 303–326.

also related to this:

McQuirk, I.S., B.K.P. Horn, H.-S. Lee, & J.L. Wyatt “Estimating the Focus of Expansion in Analog VLSI,” International Journal of Computer Visions Vol. 28, No. 3, 1998, pp. 261–277.

and

Horn, B.K.P., Y. Fang and I. Masaki, “Time to Contact Relative to a Planar Surface,” IEEE Transactions on Intelligent Transportation Systems, June 2007.

Calling a function is costly. Not only the

clock cycles for executing the jump command.

You have also to consider that maybe the state

of the local variables has to be stored

on the stack before the call and be restored

after return.

Another possibility is to work with

macros, such as #define f(x,y) ...

No function is called, but the code

defined is inserted at every place

where it is used.

Regards,

Joachim

Hello Jayakrishna,

Can you explain more your question.

is your question about making survey paper ?

The predictability of a real-time system is not related to multi-threaded applications; most of the real-time applications ARE multi-threaded in the sens that the application contains a number of threads or tasks that should be executed in a concurrent manner. In order to guarantee the execution time real-time systems use a scheduler; the scheduler may be part of the operating system or it may be part of the application. In case the application is executed on a single processor (more precisely one CPU, or core) there are a number of classical scheduling algorithms such as Rate Monotonic (RM) or Earliest Deadline First (EDF) that can find a feasible schedule that can guarantee the fulfillment of deadlines. In case of multiprocessor systems the scheduling problem is a little bit more complicated but there are solutions for particular task or thread setup.

In your case with 4 threads, if you want to achieve the same execution time as in a sequential case probably you have to use a multicore platform (e.g. quad-core).

Another parameter which significantly influence the schedulability of a set of tasks (and consequently if the WCE T- worst case execution time - of each thread is guaranteed) is the periodicity of threads or tasks - how often the threads are activated.

Most of the scheduling algorithms that offer guarantees regarding execution time are taking into consideration the periods of the threads.

So, as conclusion it is not a question of operating system, is more about a good scheduling strategy.

It depends on what level of independence you expect from the two programs. Generally the first answer would be "yes", since the usual level of independence is good for most cases. I.e. if just run on two cores, one program should not crash the other (provided the program and the OS are free of bugs). The ways in which these programms may interact is only relevant if you need very clear guarantees, e.g. real-time behavior or safety-related functions.

In case hard real-time behavior is required for example the question cannot be answered without knowing the exact hardware. You mention that the programs do not use shared resources, but this is close to impossible to realize in realistic hardware. Most times the cores of a multiprocessor share caches or the connection to main memory. So in case one programm accesses the main memory, the other may have to wait for the access to wait for the first program to finish, which can change the execution time. Or the programs may share cache lines which can also influence performance. It would even be possible that one program drives up the heat, so that the OS has to activate a power saving mode for both cores which then again degrades performance for the other program.

The point is, that the concept of two programs sharing no resources is an illusion provided by the OS and the hardware. Some resources will always be shared (and even if it is only because of physical proximity of the cores, making them share a common heat-sink). In most cases however this illusion is performed so well, that one can actually assume independence of the programs. And the cases where one has to look beyond that illusion are rare and require very special methods of development.

In short: You can not.

A bit longer: There are a number of issues if you want to use .NET for a real-time application. In general, "real time" means execution in predictable (and sufficiently short) time. .NET is not very predictable. The most important sources of non-predictability are it's JIT (run-time code generation) , the garbage collector, and the lack in real-time support of the underlying operating system.

However, there are an number of approaches to improve the real-time ability of .NET, e.g. using different GC or doing code transformation. Most approaches do not use the original .NET, but Rotor or Mono.

If soft real time is sufficient, there are a number of "tricks" you may use. E.g., starting with version 4.5 you may set the 'latency mode' to avoid overlong blocking by GC.

Did you check the "Extensions" page of Simplescalar. Long back I did use a multiprocessor simulator from RICE university.

Please, look for this website: