Pages: 1 [2] 3   Go Down
Author Topic: Does Arduino need a real-time scheduler?  (Read 28603 times)
0 Members and 2 Guests are viewing this topic.
Offline Offline
Newbie
*
Karma: 0
Posts: 42
View Profile
 Bigger Bigger  Smaller Smaller  Reset Reset

fat16lib,

I've gotten some good feedback in the form of "thanks for writing this up", but no specific additional questions on the QF hack. I've been pleased with the traffic to the specific blog post on state machines, it seems to be gaining momentum over the last month, perhaps in light of recent talk about schedulers like this.

Thanks for this post, I believe it builds awareness of some of the tools that are available for solving various control problems.



Logged

Offline Offline
Sr. Member
****
Karma: 4
Posts: 327
View Profile
 Bigger Bigger  Smaller Smaller  Reset Reset

to answer the question
   yes it dosn't

depends what your doing with the thing.

would be nice if a simple rtos was available,

as for the comment back a while about the good old 8008,
   the work on the apollo computer used a rtos / interupt / schedular system,
     its what saved the 11 mission when buzz left the  return to orbit  radar on as well as the landing radar.

http://ed-thelen.org/comp-hist/vs-mit-apollo-guidance.html

have fun
Logged

0
Offline Offline
Edison Member
*
Karma: 63
Posts: 1604
Arduino rocks
View Profile
 Bigger Bigger  Smaller Smaller  Reset Reset

Would an extremely small preemptive RTOS appeal to Arduino users?

I have been playing with an experimental RTOS written by Giovanni Di Sirio, the author of ChibiOS/RT. 

His goal is to build the smallest possible kernel for tiny chips.  Giovanni calls the system Nil RTOS since the goal is a zero size kernel.

Nil RTOS has only the most fundamental functionality.

A preemptive fixed priority scheduler.

Counting semaphores that can signal from a thread or ISR.

Sleep until a specified time and sleep for a specified period.

Here is an example sketch with a total size under 2KB  on an Uno:
Code:
// Connect a scope to pin 13.
// Measure difference in time between first pulse with no context switch
// and second pulse started in thread 2 and ended in thread 1.
// Difference should be about 10 usec on a 16 MHz 328 Arduino.
#include <NilRTOS.h>

const uint8_t LED_PIN = 13;

// Semaphore used to trigger a context switch.
Semaphore sem = {0};
//------------------------------------------------------------------------------
/*
 * Thread 1 - high priority thread to set pin low.
 */
NIL_WORKING_AREA(waThread1, 128);
NIL_THREAD(Thread1, arg) {

  while (TRUE) {
    // wait for semaphore signal
    nilSemWait(&sem);
    // set pin low
    digitalWrite(LED_PIN, LOW);
  }
}
//------------------------------------------------------------------------------
/*
 * Thread 2 - lower priority thread to toggle LED and trigger thread 1.
 */
NIL_WORKING_AREA(waThread2, 128);
NIL_THREAD(Thread2, arg) {

  pinMode(LED_PIN, OUTPUT);
  while (TRUE) {
    // first pulse to get time with no context switch
    digitalWrite(LED_PIN, HIGH);
    digitalWrite(LED_PIN, LOW);
    // start second pulse
    digitalWrite(LED_PIN, HIGH);
    // trigger context switch for task that ends pulse
    nilSemSignal(&sem);
    // sleep until next tick (1024 microseconds tick on Arduino)
    nilThdSleep(1);
  }
}
//------------------------------------------------------------------------------
/*
 * Threads static table, one entry per thread. Thread priority is determined
 * by position in table.
 */
NIL_THREADS_TABLE_BEGIN()
NIL_THREADS_TABLE_ENTRY("thread1", Thread1, NULL, waThread1, sizeof(waThread1))
NIL_THREADS_TABLE_ENTRY("thread2", Thread2, NULL, waThread2, sizeof(waThread2))
NIL_THREADS_TABLE_END()
//------------------------------------------------------------------------------
void setup() {
  // Start nil.
  nilBegin();
}
//------------------------------------------------------------------------------
void loop() {
  // Not used.
}

I wrote this sketch to determine the performance of Nil RTOS.  I was amazed to find how fast it is.  The time to signal a semaphore, do a contex switch and take the semaphore is only about 12 microseconds on an Uno.
 
Logged

Michigan, USA
Offline Offline
Newbie
*
Karma: 0
Posts: 5
View Profile
 Bigger Bigger  Smaller Smaller  Reset Reset

I have read all of this thread and found it very interesting.  I worked on powertrain controllers as a consultant for brands x and y.  They both had a mechanical engineering mind set in the early days and put any old EE on the coding for the controllers.  Glad to say that is no longer the case.  Some went kicking and screaming from absolute assembly to relocatable assembly.  Then the same with going to "C".  And, again for a RTOS.  At this time they are doing model based control algorithms and auto code generation with an RTOS.  There were safety concerns about allowing higher level interrupts interrupt lower level interrupts.  It was believed that circumstances might arise that could not be reliably predicted.  I disagreed, but I was probably wrong.  A friend working at Wind River was involved in the code for the Mars rovers.  You may recall the first rover froze up.  The software locked up.  The problem was task scheduling in the very complex multitasking RTOS.  Luckily, or cleverly, they had some code in the system that recognized how much trouble it was in and went into a mode to accept new code by telemetry.  So, by the time the second rover landed, they had the fix.  I am an old engineer 65+ and age is not the problem, mind set is.  You are either open to new ideas, or not.  I have a hobby farm and I am retired, so my current project is to use a Raspberry Pi(RPI)... (google) and an attached I/O board with an ATmega328p on it.  The ATmega is much more powerful that the first chips we ran the engine with which was (1K RAM, 16K ROM, and 2MHz).  We used a 10msec interrupt to read the tone wheels for RPM and schedule background tasks.  It was a rudimentary O/S for scheduling and accurate sensor reading.  The building security/monitoring/controlling I will do for three out buildings on the property will use a similar rudimentary O/S.  The ATmega is a slave to the RPI on a 115K serial UART channel.  The RPI is a powerful processor with 512K RAM and SD flash ROM (8Gig) with netork connector and two USB connectors.  I will run WiFi on one of the USB ports. The RPI runs Debian Linux and can do an Apache server, if you wish.  The cost is very low.  The RPI is $35 and the Gert I/O board is $48.  I was working on computerized test equipment at Bell Labs when the Intel 4004 and 8008 came out.  We were doing 148 pin circuit board testers and wanted to go to a processor per pin, but the 8008 and 4004 were not fast enough or powerful enough.  We stayed with DEC and Data General minicomputers.  Anyway, this thread was very interesting and I think that the power of the Arduino boards does warrant the use of a periodic interrupt and simple task scheduler for many applications.  I have used the 'MicroC/OS-II' real-time kernel by Jean J. Labrosse, which has been ported to many uPs.  It does a fine job and allows the user to pick features and leave out features to arrive at the proper size and power.  Worked well for me on my greenhouse controller, which reports over the internet.  I have seen another similar featured RTOS called 'freeRTOS'...(google) that costs nothing.  I think it would be useful for some to look at these.  Have fun smiley-grin.
Logged

Douglas S. Basberg, MSEE, PE
Embedded Controls Consultant
DSB Engineering, Inc.

0
Offline Offline
Edison Member
*
Karma: 63
Posts: 1604
Arduino rocks
View Profile
 Bigger Bigger  Smaller Smaller  Reset Reset

Much was made of the Mars rover bug but it was just that, a bug.  Like all bugs, it shouldn't have happened since the proper design for avoiding "priority inversion" was well known since the early 1970s.  The Mars rover problem happened in 1997.
Quote
When created, a VxWorks mutex object accepts a boolean parameter that indicates whether priority inheritance should be performed by the mutex. The mutex in question had been initialized with the parameter off; had it been on, the low-priority meteorological thread would have inherited the priority of the high-priority data bus thread blocked on it while it held the mutex, causing it be scheduled with higher priority than the medium-priority communications task, thus preventing the priority inversion. Once diagnosed, it was clear to the JPL engineers that using priority inheritance would prevent the resets they were seeing.

I did become part of the fear factor of using a RTOS.  Like this kind of misinformation - "an RTOS shouldn't be used on an Uno since the overhead is too high".

Here is a simple case study for an example I am developing.  The problem is to read data from analog pins at regular intervals and write it to an SD card.

The simple solution is a loop like this:

1. Wait till start of period.

2. Read data.

3. Write data to SD.

4. Repeat.

A problem occurs when the period between points is less than about 100 milliseconds.  SD cards can have occasional latencies of over 100 milliseconds so data overruns occur.

A possible solution is to use an RTOS with two threads.  Can the Uno support the extra overhead?

The answer is that the RTOS solution is far more efficient than the above loop.  Here's why.

The RTOS solution has two threads.

The analog read thread runs at high priority and is a loop like this:

1. Wait till start of period.

2. Read data.

3. Write data to a FIFO buffer.

4. Repeat.

The SD write thread is a loop that runs at lower priority.

1. Wait for data in the FIFO.

2. Write data to SD

3. Repeat.

The two thread solution is more efficient than the first single loop solution.  CPU time is recovered when the SD is busy and the higher priority thread is scheduled.

Now comes the real payoff.  The Arduino analogRead() take about 115 microseconds.  Almost all of this is in a busy loop waiting for the ADC conversion.

I wrote an RTOS based replacement for analogRead() that is transparent to users but sleeps during the ADC conversion.  This saves over 90 microseconds of CPU time per read after factoring in a context switch.

The result is that the RTOS version can log more than twice as fast and doesn't suffer data overruns.  The simple loop version has the high overhead of busy loops that the RTOS avoids.

I have ported three RTOSs to Arduino http://code.google.com/p/rtoslibs/.

My favorite for Uno is NilRTOS.  Its author, Giovanni Di Sirio, says it's "Smaller than ChibiOS/RT, so small it's almost nil."
Logged

0
Offline Offline
Newbie
*
Karma: 0
Posts: 7
Arduino rocks
View Profile
 Bigger Bigger  Smaller Smaller  Reset Reset

Interesting thread. I have been working on commercial hard- and soft- real-time control systems for a number of years. Since those terms are commonly misused and misunderstood here is an example of a hard-time system we did a few years ago: a mud-pump controller driving two pistons with 2-meter stroke, controlled with about 500 HP of hydraulic pumps (at 10,000 psi, the manifold pipe is something like 200 mm in dia), through a servovalve for each piston. Each piston moves by a polynomial equation and their outputs are summed through a check valve so that the flow is constant, and adjustable over a wide range. LVDTs with 2-meter stroke monitor each piston. Smooth startup and shutdown and several considerations of fail-safe behavior were used. We achieved this on an 8051 with external ADCs and DACs, and interrupt handlers (two levels, pre-emptive) with re-entrant libraries. We almost ran out of code space. In our case the time interval was not tiny, but we had hard completion deadlines. The piston profile came out of a lookup table (actually 1/4 of the entire profile, mirrored and phase-shifted as needed), the actual piston position was read, and that was all fed into a firmware PID routine which then calculated the next value for the servovalves. That had to be completed before the timer tick to update the valves. That timer got faster as the flow rate was increased. Then in the background was interrupt-driven serial I/O for the machine interface to control the mud pump and to monitor critical performance values (such as the current error value vs target position). This I/O had to be safely pre-empted by the piston routines with due consideration of atomicity of variables which might be in the midst of being updated by the control interface. In the end it all worked well, we delivered complete documentation and source code, and I have not heard of any problems. I went to Japan to help install and tune the system and then our part of the project was complete.

Where execution deadlines got tight I would set and clear some spare I/O bits and watch them on an oscilloscope or logic analyzer, something like High when active in a critical routine and Low when in safe extra time margin. As the flow rate ramped up you could see the bit transitions coming closer together. If they ever collided that would be potentially catastrophic since the control loop could not correctly function. We set the scope to trigger on the smallest safe interval and left it running overnight (without driving the actual pumps - simulated input). There was also simple instrumentation in the code to log deadline violations.

The project engineer was a delight to work with: a very experienced, practical guy. One example: we had to monitor the end-of travel limit clearance of the pistons (which weighed over 1000 kg as I recall) since we didn't ever want to drive them into their stops. No one knew what would happen if that occurred. Safe clearance was something like 5-10 mm, and it could not be observed easily by eye while running. His brilliant idea was to use an empty aluminum soft drink can in the gap and measure the crushed thickness. Worked great and no risk of harm to the pistons.

In this project a simple RTOS might have been a huge timesaver. But we also had to have timer interrupts and serial I/O interrupts and I am not aware of how easily RTOSes can fit with those. If it is possible to weave RTOS features into your own needed I/O hardware support, that could be helpful but also could get a bit complex.

I am using Teensy++2 on a project now and just got the ARM Teensy 3, and there is enough code and data space on these new Arduino devices. My concern would be: is the RTOS granular so we only need to use what fits our case, and can it co-exist with I/O device interrupt handlers?

Thanks
Logged

0
Offline Offline
Edison Member
*
Karma: 63
Posts: 1604
Arduino rocks
View Profile
 Bigger Bigger  Smaller Smaller  Reset Reset

Quote
In this project a simple RTOS might have been a huge timesaver. But we also had to have timer interrupts and serial I/O interrupts and I am not aware of how easily RTOSes can fit with those. If it is possible to weave RTOS features into your own needed I/O hardware support, that could be helpful but also could get a bit complex.
Quote
My concern would be: is the RTOS granular so we only need to use what fits our case, and can it co-exist with I/O device interrupt handlers?
A good RTOS allows independent interrupt handlers.  The three systems I ported to AVR/ARM Arduinos can be used as simple kernels with all I/O from the Arduino core or custom libraries.

I am starting to write optional I/O libraries that are integrated with the RTOS.  Many existing Arduino I/O functions just do busy loops so putting a thread to sleep and waking it with an I/O done interrupt is more efficient.

If you need a highly optimized ISRs, systems like ChibiOS are designed to allow your ISR to run with no interference from the RTOS.

On ARM this works very well with priority interrupts.  ChibiOS is designed to allow "Fast interrupts".
Quote
On some architectures ChibiOS supports a special class of “Fast Interrupts”, such interrupt sources have a higher hardware priority than the kernel so it is not possible to invoke system APIs from there.

The invocation of any API is forbidden here because fast interrupt handlers can preempt the kernel even within its critical zones in order to minimize latency.

The only hardware resource I uses is access to a timer interrupt for the system tick. 

I piggyback on sysTick on ARM since both Teensy 3.0 and Due will have a hook.  So no new hardware is used on ARM.

On AVR I am using the timer 0 compare A interrupt.  I did this so no Arduino core code needs to be changed.  I will release an optional patch to piggyback on the timer 0 overflow interrupt.  This is already used for delay(), millis(), and micros().  Then not new hardware will be used on AVR.
« Last Edit: February 05, 2013, 04:05:04 pm by fat16lib » Logged

Offline Offline
Newbie
*
Karma: 0
Posts: 7
View Profile
 Bigger Bigger  Smaller Smaller  Reset Reset

I first started with Netduino, then switched to Arduino because of more hardware and components and also cheaper, I'm now fiddling with some RF components and I really really need Threads, I don't know exactly what threads are in .NET and what is the importance of RTOS. But I need precision timing, and execution from a couple of wirelessly enabled arduino units. Think of it as a wireless sequential light system, I messed with millis(), timers and lots of libraries, all are unpredictable and hang. Or just drift apart as time goes by in execution. I dunno maybe im doing something wrong, but when I used Netduino I could do this preety easily.

Anyway its explained like this:

Quote
The .NET Micro Framework CLR has only one thread of execution and owns all of the memory in the system. During normal operation, the CLR iterates in the interpreter loop and schedules managed threads using a round-robin algorithm, according to the priority of the threads involved. Each managed thread gets a 20-millisecond (ms) time quantum during which the runtime executes intermediate language (IL) code that belongs to the stack of the managed thread being serviced. When the managed thread goes to sleep or waits for a synchronization primitive, such as a monitor that cannot be acquired or an event that is not signaled, the CLR puts the thread in the waiting queue and tries to schedule another thread. In between scheduling managed threads, the CLR checks for any hardware events that might have been raised at the native device driver level. If an event occurred, the CLR tries to dispatch the event to the managed thread that requested it. A hardware event is associated with some kind of input/output (I/O) event, whether it be an interrupt-based GPIO event or a serial USART, USB, or I2C event.

The runtime interpreter loop starts by checking to discover whether a thread is ready for a time slice. If a thread is ready, the CLR schedules the thread for processing and tests to determine whether any hardware interrupt events require processing. If there are, the CLR processes the hardware interrupt event and moves the thread that handles the interrupt into the queue of threads that are ready to be processed. If no hardware interrupts have occurred, the CLR again tests to see whether a thread is ready for a time slice.

If the CLR determines that there are no threads that are ready to be processed, it sets a timeout timer and goes to sleep in order to conserve power. When the timeout timer triggers or an interrupt occurs, it wakes the CLR back up. At that time, the CLR determines whether an interrupt or the timer woke it up. If it was an interrupt, the CLR determines if processing the interrupt is required. If not, it sets the timeout timer and goes back to sleep. If it is the timeout timer that wakes the CLR, the CLR executes any pending completions and checks again for interrupts. If there are waiting interrupts, it goes through the normal interrupt processing procedures. If there are no waiting interrupts, the CLR sets its timeout timer and goes back to sleep.

Basic example with Netduino
Code:
namespace NetduinoApplication1
{
    public class Program
    {

        static Thread myThread = new Thread(new ThreadStart(myFunc));
       
        public static void Main()
        {
            myThread.Start();

            //suspend at some point, wait for event
            //myThread.Suspend();

            //resume at some point, wait for event
            //myThread.Resume();

            Thread.Sleep(Timeout.Infinite);
        }

        public static void myFunc() {
            // do some stuff
        }

    }
}
Logged

Offline Offline
Newbie
*
Karma: 0
Posts: 1
German software engineer and ham with a hardware background
View Profile
WWW
 Bigger Bigger  Smaller Smaller  Reset Reset

My opinion: Arduino needs a better delay() function  smiley-mr-green

The question RTOS or no RTOS does just heat up the discussion, but does not help the migration. This is my approach:
I want a better delay() function - this is a feeling. If I introspect this feeling I recognize
- it is a waste of energy for me if delay() is just doing busy waiting.
- I want/I need to do several things in parallel, but delay() does not allow me to do it.
- I do not want to throw everything away because of a bigbang RTOS solution, I want to go step by step from here to there.

As a seasoned software engineer I have seen again and again that migration is the key. Here are my suggestions:

Migration step 1: Introduce event handling
--------------------------------------------
The Arduino "core library" has the loop() function. An event handling Arduino program will have one only statement in the loop() function, the do_event() function. The do_event() function has to look after the events and has to service the events.
A useful vehicle to show that event handling is useful should be a keyboard scan library that provides its services within an event handling framework. The typical pocket calculator keyboard has arranged the keys between row and column lines. A 12 button keyboard needs 3+4=7 scan lines. The keyboard scan function is not trivial. Everybody expects to get:
- key debouncing
- key repeat (repetition)
- 2-keys-rollover (Rapid typists may sometimes inadvertently press a key before releasing the previous one)
- no electrical shortcircuit if two keys are pressed simultaneously
To implement these functions, a timer is needed. The keyboard lib should provide a timeout functionality to the user. The function set of the keyboard lib is:
button_register(): combine an event (key press) to a function (eventhandler)
after(): after N milliseconds call a function
every(): every N milliseconds call a function
do_event(): check if there is a pending event and execute the eventhandler function. Needs to be called again and again within loop().

A simple Arduino program that fits nicely the event paradigma is a math trainer program. The Arduino displays a math question like "1 + 2 = ?" and the user should enter the correct answer within a time limit. In an event program there will be a keyboard event for every digit and a timeout event. If the user presses the digit "3", the button-3-event function will say "correct answer". The other button-event functions will say "wrong answer". And the timeout event-function will say "timeout".

Migration step 2: Create a event-driven LiquidCrystal lib
----------------------------------------------------------
Everybody is using LiquidCrystal. But LiquidCrystal uses delay() and busy waiting is the nemesis to all real time programming. Thanks to the keyboard lib above, we have one-shot timer. And an event driven LCD output function does look like this:
do_lcd() {
switch (state) {
case 1: // do state 1 stuff
  state=2; after(N, do_lcd); return; // set next state, use after to delay execution by N milliseconds, exit do_lcd()
case 2: // do state 2 stuff
  state=3; after(M, do_lcd); return; // set next state, use after to delay execution by M milliseconds, exit do_lcd()
} }

The busy waiting version of do_lcd() was:
do_lcd() {
  // do state 1 stuff
  delay(N);
  // do state 2 stuff
  delay(M);
} }

The do_lcd() function is ugly, but it is working without busy waiting. If all Arduino users are annoyed by event handling uglyness, they are ready for phase 3 of the RTOS brainwash program:

Migration step 3: Show that multi-threading does look better
----------------------------------------------------------------
Multi threading is dangerous. The worst thing you can do with busy waiting is to freeze everything up. The worst thing in multi threading is that you literally tear apart your machine because thread 1 says "go left" and thread 2 says "go right" as fast as time-division multiplexing can do. But, if you have multi-threading and a multi-threaded version of delay(), the do_lcd() function will no longer look ugly, and you are still out of busy waiting land:

do_lcd() {
  // do state 1 stuff
  delay(N); // the multi-thread version of delay() will switch to another thread or will wait in the operating system
  // do state 2 stuff
  delay(M); // the multi-thread version of delay() will switch to another thread or will wait in the operating system
} }

I bet, everybody will be happy about a keyboard() lib. And they will learn that "fu**ing" event crap, because using a lib is better then writing a lib. And everybody who uses keyboard() will use after() and every(). And now the future is open: If you can live with the event programming uglyness, you never have to go to multi-threading land. Maybe you remember the X windows system, the GUI for UNIX and Linux? Well this was all done by using event programming, and it was done a long time before multi-threading was invented.
Logged

Offline Offline
Newbie
*
Karma: 0
Posts: 7
View Profile
 Bigger Bigger  Smaller Smaller  Reset Reset

My opinion: Arduino needs a better delay() function  smiley-mr-green

The question RTOS or no RTOS does just heat up the discussion, but does not help the migration. This is my approach:
I want a better delay() function - this is a feeling. If I introspect this feeling I recognize
- it is a waste of energy for me if delay() is just doing busy waiting.
- I want/I need to do several things in parallel, but delay() does not allow me to do it.
- I do not want to throw everything away because of a bigbang RTOS solution, I want to go step by step from here to there.

As a seasoned software engineer I have seen again and again that migration is the key. Here are my suggestions:

Migration step 1: Introduce event handling
--------------------------------------------
The Arduino "core library" has the loop() function. An event handling Arduino program will have one only statement in the loop() function, the do_event() function. The do_event() function has to look after the events and has to service the events.
A useful vehicle to show that event handling is useful should be a keyboard scan library that provides its services within an event handling framework. The typical pocket calculator keyboard has arranged the keys between row and column lines. A 12 button keyboard needs 3+4=7 scan lines. The keyboard scan function is not trivial. Everybody expects to get:
- key debouncing
- key repeat (repetition)
- 2-keys-rollover (Rapid typists may sometimes inadvertently press a key before releasing the previous one)
- no electrical shortcircuit if two keys are pressed simultaneously
To implement these functions, a timer is needed. The keyboard lib should provide a timeout functionality to the user. The function set of the keyboard lib is:
button_register(): combine an event (key press) to a function (eventhandler)
after(): after N milliseconds call a function
every(): every N milliseconds call a function
do_event(): check if there is a pending event and execute the eventhandler function. Needs to be called again and again within loop().

A simple Arduino program that fits nicely the event paradigma is a math trainer program. The Arduino displays a math question like "1 + 2 = ?" and the user should enter the correct answer within a time limit. In an event program there will be a keyboard event for every digit and a timeout event. If the user presses the digit "3", the button-3-event function will say "correct answer". The other button-event functions will say "wrong answer". And the timeout event-function will say "timeout".

Migration step 2: Create a event-driven LiquidCrystal lib
----------------------------------------------------------
Everybody is using LiquidCrystal. But LiquidCrystal uses delay() and busy waiting is the nemesis to all real time programming. Thanks to the keyboard lib above, we have one-shot timer. And an event driven LCD output function does look like this:
do_lcd() {
switch (state) {
case 1: // do state 1 stuff
  state=2; after(N, do_lcd); return; // set next state, use after to delay execution by N milliseconds, exit do_lcd()
case 2: // do state 2 stuff
  state=3; after(M, do_lcd); return; // set next state, use after to delay execution by M milliseconds, exit do_lcd()
} }

The busy waiting version of do_lcd() was:
do_lcd() {
  // do state 1 stuff
  delay(N);
  // do state 2 stuff
  delay(M);
} }

The do_lcd() function is ugly, but it is working without busy waiting. If all Arduino users are annoyed by event handling uglyness, they are ready for phase 3 of the RTOS brainwash program:

Migration step 3: Show that multi-threading does look better
----------------------------------------------------------------
Multi threading is dangerous. The worst thing you can do with busy waiting is to freeze everything up. The worst thing in multi threading is that you literally tear apart your machine because thread 1 says "go left" and thread 2 says "go right" as fast as time-division multiplexing can do. But, if you have multi-threading and a multi-threaded version of delay(), the do_lcd() function will no longer look ugly, and you are still out of busy waiting land:

do_lcd() {
  // do state 1 stuff
  delay(N); // the multi-thread version of delay() will switch to another thread or will wait in the operating system
  // do state 2 stuff
  delay(M); // the multi-thread version of delay() will switch to another thread or will wait in the operating system
} }

I bet, everybody will be happy about a keyboard() lib. And they will learn that "fu**ing" event crap, because using a lib is better then writing a lib. And everybody who uses keyboard() will use after() and every(). And now the future is open: If you can live with the event programming uglyness, you never have to go to multi-threading land. Maybe you remember the X windows system, the GUI for UNIX and Linux? Well this was all done by using event programming, and it was done a long time before multi-threading was invented.


Well, I don't know exactly what you mean by this, do you condone one way or the other, but I for sure am not a software architect and there for will not write my own state machine, I expect this to be handled by the framework so I can focus on my logic level. I expect to write a couple of lines of code to get a couple of lines of logic nothing fancy nothing hard.
Logged

SF Bay Area (USA)
Offline Offline
Tesla Member
***
Karma: 124
Posts: 6652
Strongly opinionated, but not official!
View Profile
 Bigger Bigger  Smaller Smaller  Reset Reset

Yeah, I think we need to stop thinking of the implementation, and start thinking about what the API should look like if it's going to be usable by "The Arduino Community."

timer mytimer;
void timerSet(mytimer, timeInms)
void timerSet(mytimer, hours, int minutes, int seconds)
boolean timerExpired(mytimer)
long timerTimeLeft(mytimer)

alarmClock myclock
alarmClockSet()
alarmSet(endTime)

In this case "timers" implement a delay for some duration, while alarmclocks implement checking whether some absolute time has ocurred.
Logged

Hertfordshire, U.K.
Offline Offline
Jr. Member
**
Karma: 2
Posts: 84
View Profile
 Bigger Bigger  Smaller Smaller  Reset Reset

If you want to cater for a hobbyist like myself with a non-software background, then it's essential to provide good clear documentation.

I for one will alway choose a library of any complexity that has good clear documentation, even at the expense of overlooking a possible more suitable one where I'm expected to wade through the code to deduce its workings.

My interest in scheduling is because I'm reading a few sensors with an Arduino.. I'm using Dr Liu's 'phi_prompt' menu library to select and display the values on an LCD. Unfortunately the phi_prompt  library sits in loops waiting for user input, during which the sensors aren't read, so I'm looking for a way round the problem and suspect the way forward may be some sort of scheduling system.  I'll look at NilRTOS (thanks 'fatlib16'!), but I've not seen a big fat PDF file describing it, so I may not get far!

Jim
Logged

Offline Offline
Newbie
*
Karma: 1
Posts: 24
View Profile
 Bigger Bigger  Smaller Smaller  Reset Reset

Yeah, I think we need to stop thinking of the implementation, and start thinking about what the API should look like if it's going to be usable by "The Arduino Community."

timer mytimer;
void timerSet(mytimer, timeInms)
void timerSet(mytimer, hours, int minutes, int seconds)
boolean timerExpired(mytimer)
long timerTimeLeft(mytimer)

alarmClock myclock
alarmClockSet()
alarmSet(endTime)

In this case "timers" implement a delay for some duration, while alarmclocks implement checking whether some absolute time has ocurred.

How about simply  "sleep(x);"  like ...

code here;            /* Last line to run before sleeping     */
sleep(100);          /* Thread goes to sleep here             */ 
code here;           /* Thread wakes up here after delay */

sleep(); causes THIS thread to release the CPU back to the RTOS.
Other threads can run while this thread is sleeping.
When the Timer Expires then the Interrupt allows the RTOS to "wake up" the sleeping thread.

Logged

SF Bay Area (USA)
Offline Offline
Tesla Member
***
Karma: 124
Posts: 6652
Strongly opinionated, but not official!
View Profile
 Bigger Bigger  Smaller Smaller  Reset Reset

Quote
sleep(); causes THIS thread to release the CPU back to the RTOS.
No, no!  If we had an RTOS with threads we can just use delay() (naming conflicts aside.)
I want to know what APIs we can use FROM NOTHING, because I think basic RTOS concepts are too difficult.
Logged

Offline Offline
Newbie
*
Karma: 1
Posts: 24
View Profile
 Bigger Bigger  Smaller Smaller  Reset Reset

Quote
sleep(); causes THIS thread to release the CPU back to the RTOS.
No, no!  If we had an RTOS with threads we can just use delay() (naming conflicts aside.)
I want to know what APIs we can use FROM NOTHING, because I think basic RTOS concepts are too difficult.

OK, Use the word "delay(x)" .
It does not matter what you name.
Although, many RTOS use sleep() as it more accurate description of what actually occurring.
It was the concept that: "THREADS SHOULD NOT BLOCK".
This is one difference between multi-threaded vs. single thread.
And is the best way to utilize CPU resources.

Also, if you want to use a Single Thread in RTOS then you can still do that.
It is not required that you make you App multi-threaded.
Multi-Threading Is an option that is available if you have the skill set to use it.

Much like using the more advanced "Interrupt Driven" Threads we can use now.

Logged

Pages: 1 [2] 3   Go Up
Jump to: