Made Process setters atomic

Author: wizard97

README.md

@@ -1,62 +1,62 @@
-# ArduinoServiceScheduler
-An Arduino Object Oriented Cooperative Service Scheduler to Replace Them All
+# ArduinoProcessScheduler
+An Arduino Object Oriented Cooperative Process Scheduler to Replace Them All
 
 ## Features
-- Fine Grained Control Over How Often a Service Runs (Periodically, Iterations, or as Often as Possible)
+- Fine Grained Control Over How Often a Process Runs (Periodically, Iterations, or as Often as Possible)
 - Exception Handling (wait what?!)
 - Atomicity Support
-- Dynamically Add/Remove and Enable/Disable Services
-- Automatic Service Monitoring Statsitics (Automatically calculates % CPU time for service)
-- Truly object orinted (a Service is no longer just a callback function like other libraries)
+- Dynamically Add/Remove and Enable/Disable Processes
+- Automatic Process Monitoring Statistics (Automatically calculates % CPU time for service)
+- Truly object oriented (a Process is no longer just a callback function like other libraries)
 
 ## Basic Usage
-There are two classes to worry about: `Scheduler` and `Service`.
+There are two classes to worry about: `Scheduler` and `Process`.
 
 ### Class `Scheduler`:
-A `Scheduler` oversees and maanges `Services`. There should only be one `Scheduler` in your project. Inside of `void loop()`, the scheduler's `run()` method should be repeatedly called.
+A `Scheduler` oversees and manages `Processes`. There should only be one `Scheduler` in your project. Inside of `void loop()`, the scheduler's `run()` method should be repeatedly called.
 
-### Class `Service`:
-A service can be thought of as job or a task that needs to be run at certain times. Each Service had be scheduled to run Periodically
+### Class `Process`:
+A service can be thought of as job or a task that needs to be run at certain times. Each Process had be scheduled to run Periodically
 Constantly, or Periodically/Constantly with a set number of run iterations.
 
-Each project will have multiple services, here are some examples of `Services`:
-  - A Service to handle user input
-  - A Service to run a basic webserver
-  - A Service to update a display
-  
-`Service` is a base class that should be extended to handle your particular Service (such as the examples mentioned above). The scheduler's will call the following virtual function as an entry point when it is time for you service to run:
+Each project will have multiple services, here are some examples of `Processes`:
+  - A Process to handle user input
+  - A Process to run a basic webserver
+  - A Process to update a display
+
+`Process` is a base class that should be extended to handle your particular Process (such as the examples mentioned above). The scheduler's will call the following virtual function as an entry point when it is time for you service to run:
 ```
     virtual void service();
 ```
-From here your `service()` routine is expected to be non-blocking, and return from `service()` as soon as possible (that means no long `delay()`'s). Fortunately, since your service routine is a method inside a class, you can store the state of your service in custom class attributes before returning, so you know where you left off when the scheduler calls your Service again. As soon you return from `service()`, control is transferred back to the Scheduler (it will also be transferred back if you raise an Exception--advanced).
+From here your `service()` routine is expected to be non-blocking, and return from `service()` as soon as possible (that means no long `delay()`'s). Fortunately, since your service routine is a method inside a class, you can store the state of your service in custom class attributes before returning, so you know where you left off when the scheduler calls your Process again. As soon you return from `service()`, control is transferred back to the Scheduler (it will also be transferred back if you raise an Exception--advanced).
 
-Additionally, each Service inherits the following virtual functions which are called by the `Scheduler` at the appropriate times. Note you are guaranteed that only one of these methods will exist in the call stack at once, even if an interrupt fires trying to modify this Service at the same time (such as with `add()`, `destroy()`, `enable()`, or `disable()`). This also includes the `service()` method mentioned above. You do not have to worry about concurrency!
+Additionally, each Process inherits the following virtual functions which are called by the `Scheduler` at the appropriate times. Note you are guaranteed that only one of these methods will exist in the call stack at once, even if an interrupt fires trying to modify this Process at the same time (such as with `add()`, `destroy()`, `enable()`, or `disable()`). This also includes the `service()` method mentioned above. You do not have to worry about concurrency!
 
-**Thanks to the magic of virtual functions, you don't have to impliment any of these unless your particular Service needs them:**
+**Thanks to the magic of virtual functions, you don't have to impliment any of these unless your particular Process needs them:**
 ```
     virtual void setup()
     virtual void cleanup()
-    
+
     virtual void onEnable()
     virtual void onDisable()
-    
+
     virtual void overScheduledHandler(uint32_t behind)
 ```
 
 #### `setup()`
-This method is called by the scheduler when the Service is being added to the scheduling chain with `add()`, it is guaranteed to only be called once when a Service not part of the scheduling chain is being added (`add()`). Keep in mind it will still be called if the Service is removed from the scheduling chain with `destroy()`, then added again with `add()`. 
+This method is called by the scheduler when the Process is being added to the scheduling chain with `add()`, it is guaranteed to only be called once when a Process not part of the scheduling chain is being added (`add()`). Keep in mind it will still be called if the Process is removed from the scheduling chain with `destroy()`, then added again with `add()`.
 
 #### `cleanup()`
-This is only called once when a `Service` part of the scheduling chain is being removed from the scheduling chain with `destroy()`. This method should undo whatever was done in `setup()`. You are guaranteed it will not be called unless `setup()` was called previously.
+This is only called once when a `Process` part of the scheduling chain is being removed from the scheduling chain with `destroy()`. This method should undo whatever was done in `setup()`. You are guaranteed it will not be called unless `setup()` was called previously.
 
 #### `onEnable()`
-This method is called only once when a disabled task is being enabled with `enable()`. 
+This method is called only once when a disabled task is being enabled with `enable()`.
 
 #### `onDisable()`
 This method is called only once when a enabled task is being disabled with `disable()`. You are guaranteed it will not be called unless `onEnable()` was called previously. It should undo whatever `onEnable()` did.
 
 #### `overScheduledHandler(uint32_t behind)`
-This method is called if the scheduler can not meet the current set period for the Service and is falling behind. The scheduler will pass in variable `behind` containing how many milliseconds (or microseconds) behind the scheduler is with this task. Inside this method might be a good time increase the period between when this task is run, then call `resetSchedulerWarning()` to clear the warning.
+This method is called if the scheduler can not meet the current set period for the Process and is falling behind. The scheduler will pass in variable `behind` containing how many milliseconds (or microseconds) behind the scheduler is with this task. Inside this method might be a good time increase the period between when this task is run, then call `resetSchedulerWarning()` to clear the warning.
 
 
 ## API
@@ -85,45 +85,45 @@ ___
 
 #### getID()
 ```
-getID(Service &service)
+getID(Process &service)
 ```
 Get the unique id for the service. Same as `service.getID()`.
 
 **Returns:** `uint8_t`
 ___
 
-#### isRunningService()
+#### isRunningProcess()
 ```
-isRunningService(Service &service)
+isRunningProcess(Process &service)
 ```
-Determine if the scheduler is in the middle of running this service. Same as calling `service.isRunningService()`
+Determine if the scheduler is in the middle of running this service. Same as calling `service.isRunningProcess()`
 
 **Returns:** `bool`
 ___
 
 #### isEnabled()
 ```
-isEnabled(Service &service)
+isEnabled(Process &service)
 ```
 Determines if this service is enabled. Same as calling `service.isEnabled()`
 
 **Returns:** `bool`
 ___
 
-#### getCurrService()
+#### getCurrProcess()
 ```
-getCurrService()
+getCurrProcess()
 ```
 Get pointer to the current service being run by the scheduler. Return NULL if no service being currently run.
 
-**Returns:** `Service*`
+**Returns:** `Process*`
 ___
 
-#### countServices()
+#### countProcesses()
 ```
-countServices(bool enabledOnly = true)
+countProcesses(bool enabledOnly = true)
 ```
-Get number of servies in the scheduler's chain. If enabledOnly is true, only the enabled Services will be counted.
+Get number of servies in the scheduler's chain. If enabledOnly is true, only the enabled Processes will be counted.
 
 **Returns:** `uint8_t`
 ___
@@ -140,7 +140,7 @@ ___
 
 #### add()
 ```
-add (Service &service))
+add (Process &service))
 ```
 Add the service to the scheduler, same as calling `service.add()`. Note, this will trigger the service's `setup()` method to fire. This method can only fail inside an interrupt routine, particularly when an interrupt interrupts any call to either `add()` or `remove()`. It will also fail if the service is already added.
 
@@ -149,16 +149,16 @@ ___
 
 #### destroy()
 ```
-destroy (Service &service))
+destroy (Process &service))
 ```
-Remove the service from the scheduler. Same as calling `service.destroy()`. Note, this will trigger the service's `cleanup()` method to fire. If the service is not disabled, it will first call `disable()`. This method can only fail inside an interrupt routine, particularly when an interrupt interrupts any call to either `add()` or `remove()`. It will first try and QUEUE the request for later, before failing. It will also fail if the service is already destroyed. 
+Remove the service from the scheduler. Same as calling `service.destroy()`. Note, this will trigger the service's `cleanup()` method to fire. If the service is not disabled, it will first call `disable()`. This method can only fail inside an interrupt routine, particularly when an interrupt interrupts any call to either `add()` or `remove()`. It will first try and QUEUE the request for later, before failing. It will also fail if the service is already destroyed.
 
 **Returns:** type `SchedulerAction`, `ACTION_NONE` on failure, `ACTION_QUEUED` on Queuing it, `ACTION_SUCCESS` on success.
 ___
 
 #### enable()
 ```
-enable (Service &service))
+enable (Process &service))
 ```
 Enable a service, same as calling `service.enable()`. Note, this will trigger the service's `onEnable()` method to fire. This method call will always succeed if it was not called on itself from a method inside of this service. If it was, the scheduler will queue the request. Also, the request will fail if the service is already enabled or is destroyed.
 
@@ -167,7 +167,7 @@ ___
 
 #### disable()
 ```
-disable (Service &service))
+disable (Process &service))
 ```
 Disable a service, same as calling `service.disable()`. Note, this will trigger the service's `onDisable()` method to fire. This method call will always succeed if it was not called on itself from a method inside of this service. If it was, the scheduler will queue the request. Also, the request will fail if the service is already enabled or is destroyed.
 

src/ProcessScheduler/Process.cpp

@@ -51,6 +51,25 @@
             (getIterations() == RUNTIME_FOREVER || getIterations() > 0))));
     }
 
+    void Process::setIterations(int iterations)
+    {
+        ATOMIC_START
+        {
+            _iterations = iterations;
+        }
+        ATOMIC_END
+    }
+
+
+    void Process::setPeriod(uint32_t period)
+    {
+        ATOMIC_START
+        {
+            _period = period;
+        }
+        ATOMIC_END
+    }
+
 
 
     /*********** PROTECTED *************/

src/ProcessScheduler/Process.h

@@ -41,8 +41,8 @@ class Process
     inline uint16_t getCurrPBehind() { return _pBehind; }
 
     ///////////////////// SETTERS /////////////////////////
-    inline void setIterations(int iterations) { _iterations = iterations; }
-    inline void setPeriod(uint32_t period) { _period = period; }
+    void setIterations(int iterations);
+    void setPeriod(uint32_t period);
     inline void force() { _force = true; }
 
     inline void resetOverSchedWarning() { _pBehind = 0; }

src/ProcessScheduler/Scheduler.cpp

@@ -256,6 +256,7 @@ void Scheduler::procAdd(Process &process)
 
 void Scheduler::procHalt()
 {
+
     for (uint8_t i = 0; i < NUM_PRIORITY_LEVELS; i++)
     {
         for (Process *curr = _pLevels[i].head; curr != NULL; curr = curr->getNext())
@@ -264,6 +265,8 @@ void Scheduler::procHalt()
         }
     }
 
+    delay(100);
+
     HALT_PROCESSOR();
 }