taskshare.h

Go to the documentation of this file.

 
/*    THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
 *    IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
 *    THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR 
 *    PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIB-
 *    UTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY,
 *    OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 
 *    SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 *    INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 
 *    CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 
 *    ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
 *    THE POSSIBILITY OF SUCH DAMAGE. */
 
// This define prevents this .h file from being included more than once
#ifndef _TASKSHARE_H_
#define _TASKSHARE_H_
 
#include "baseshare.h"                      // Base class for shared data items
#include "FreeRTOS.h"                       // Main header for FreeRTOS
 
template <class DataType> class Share : public BaseShare
{
protected:
    QueueHandle_t queue;
 
public:
    Share<DataType> (const char* p_name = NULL) : BaseShare (p_name)
    {
        queue = xQueueCreate (1, sizeof (DataType));
    }
 
    void put (DataType new_data)
    {
        xQueueOverwrite (queue, &new_data);
    }
 
    void ISR_put (DataType new_data)
    {
        BaseType_t wake_up;
        xQueueOverwriteFromISR (queue, &new_data, &wake_up);
    }
 
    void operator << (DataType new_data)
    {
        if (CHECK_IF_IN_ISR ())
        {
            BaseType_t wake_up;
            xQueueOverwriteFromISR (queue, &new_data, &wake_up);
        }
        else
        {
            xQueueOverwrite (queue, &new_data);
        }
    }
 
    void operator >> (DataType put_here)
    {
        if (CHECK_IF_IN_ISR ())
        {
            // Copy the data from the queue into the receiving variable
            xQueuePeekFromISR (queue, &put_here);
        }
        else
        {
            xQueuePeek (queue, &put_here, portMAX_DELAY);
        }
    }
 
    void get (DataType& recv_data)
    {
        // Copy the data from the queue into the receiving variable
        xQueuePeek (queue, &recv_data, portMAX_DELAY);
    }
 
    DataType get (void)
    {
        DataType return_this;
    
        // Copy the data from the queue into the receiving variable
        xQueuePeek (queue, &return_this, portMAX_DELAY);
 
        return return_this;
    }
 
    void ISR_get (DataType& recv_data)
    {
        xQueuePeekFromISR (queue, &recv_data);
    }
 
    DataType ISR_get (void)
    {
        DataType return_this;
        xQueuePeekFromISR (queue, &return_this);
        return return_this;
    }
 
    // Print the share's status within a list of all shares' statuses
    void print_in_list (Print& printer);
 
}; // class TaskShare<DataType>
 
 
template <class DataType>
void Share<DataType>::print_in_list (Print& printer)
{
    // Print this task's name and pad it to 16 characters
    printer.printf ("%-16sshare\t", name);
 
    // End the line
    printer << endl;
 
    // Call the next item
    if (p_next != NULL)
    {
        p_next->print_in_list (printer);
    }
}
 
#endif  // _TASKSHARE_H_