mailbox.h

Go to the documentation of this file.

/*===========================================================================
     _____        _____        _____        _____
 ___|    _|__  __|_    |__  __|__   |__  __| __  |__  ______
|    \  /  | ||    \      ||     |     ||  |/ /     ||___   |
|     \/   | ||     \     ||     \     ||     \     ||___   |
|__/\__/|__|_||__|\__\  __||__|\__\  __||__|\__\  __||______|
    |_____|      |_____|      |_____|      |_____|

--[Mark3 Realtime Platform]--------------------------------------------------

Copyright (c) 2012 - 2019 m0slevin, all rights reserved.
See license.txt for more information
===========================================================================*/
#pragma once

#include "mark3cfg.h"
#include "kerneltypes.h"
#include "ithreadport.h"
#include "ksemaphore.h"

namespace Mark3
{
class Mailbox
{
public:
    void* operator new(size_t sz, void* pv) { return reinterpret_cast<Mailbox*>(pv); }
    ~Mailbox();

    void Init(void* pvBuffer_, uint16_t u16BufferSize_, uint16_t u16ElementSize_);

    static Mailbox* Init(uint16_t u16BufferSize_, uint16_t u16ElementSize_);

    bool Send(void* pvData_);

    bool SendTail(void* pvData_);

    bool Send(void* pvData_, uint32_t u32TimeoutMS_);

    bool SendTail(void* pvData_, uint32_t u32TimeoutMS_);

    void Receive(void* pvData_);

    void ReceiveTail(void* pvData_);

    bool Receive(void* pvData_, uint32_t u32TimeoutMS_);

    bool ReceiveTail(void* pvData_, uint32_t u32TimeoutMS_);

    uint16_t GetFreeSlots(void)
    {
        const auto cs = CriticalGuard{};
        return m_u16Free;
    }

    bool IsFull(void) { return (GetFreeSlots() == 0); }
    bool IsEmpty(void) { return (GetFreeSlots() == m_u16Count); }

private:
    void* GetHeadPointer(void)
    {
        auto uAddr = reinterpret_cast<K_ADDR>(m_pvBuffer);
        uAddr += static_cast<K_ADDR>(m_u16ElementSize) * static_cast<K_ADDR>(m_u16Head);
        return reinterpret_cast<void*>(uAddr);
    }

    void* GetTailPointer(void)
    {
        auto uAddr = reinterpret_cast<K_ADDR>(m_pvBuffer);
        uAddr += static_cast<K_ADDR>(m_u16ElementSize) * static_cast<K_ADDR>(m_u16Tail);
        return reinterpret_cast<void*>(uAddr);
    }

    void CopyData(const void* src_, void* dst_, uint16_t len_)
    {
        auto* u8Src = reinterpret_cast<const uint8_t*>(src_);
        auto* u8Dst = reinterpret_cast<uint8_t*>(dst_);
        while (len_--) { *u8Dst++ = *u8Src++; }
    }

    void MoveTailForward(void)
    {
        m_u16Tail++;
        if (m_u16Tail == m_u16Count) {
            m_u16Tail = 0;
        }
    }

    void MoveHeadForward(void)
    {
        m_u16Head++;
        if (m_u16Head == m_u16Count) {
            m_u16Head = 0;
        }
    }

    void MoveTailBackward(void)
    {
        if (m_u16Tail == 0) {
            m_u16Tail = m_u16Count;
        }
        m_u16Tail--;
    }

    void MoveHeadBackward(void)
    {
        if (m_u16Head == 0) {
            m_u16Head = m_u16Count;
        }
        m_u16Head--;
    }

    bool Send_i(const void* pvData_, bool bTail_, uint32_t u32TimeoutMS_);

    bool Receive_i(void* pvData_, bool bTail_, uint32_t u32WaitTimeMS_);

    uint16_t m_u16Head; 
    uint16_t m_u16Tail; 

    uint16_t          m_u16Count; 
    volatile uint16_t m_u16Free;  

    uint16_t    m_u16ElementSize; 
    const void* m_pvBuffer;       

    Semaphore m_clRecvSem; 
    Semaphore m_clSendSem; 
};
} // namespace Mark3