spiram_alloc.h

Go to the documentation of this file.

#ifndef VIRTMEM_SPIRAM_ALLOC_H
#define VIRTMEM_SPIRAM_ALLOC_H

#include <Arduino.h>
#include "internal/alloc.h"

#include <serialram.h>

namespace virtmem {

template <typename Properties=DefaultAllocProperties>
class SPIRAMVAllocP : public VAlloc<Properties, SPIRAMVAllocP<Properties> >
{
    bool largeAddressing;
    uint8_t chipSelect;
    SerialRam::ESPISpeed SPISpeed;
    SerialRam serialRAM;

    void doStart(void)
    {
        serialRAM.begin(largeAddressing, chipSelect, SPISpeed);
    }

    void doStop(void)
    {
        serialRAM.end();
    }

    void doRead(void *data, VPtrSize offset, VPtrSize size)
    {
//        const uint32_t t = micros();
        serialRAM.read((char *)data, offset, size);
//        Serial.print("read: "); Serial.print(offset); Serial.print("/"); Serial.print(size); Serial.print("/"); Serial.println(micros() - t);
    }

    void doWrite(const void *data, VPtrSize offset, VPtrSize size)
    {
//        const uint32_t t = micros();
        serialRAM.write((const char *)data, offset, size);
//        Serial.print("write: "); Serial.print(offset); Serial.print("/"); Serial.print(size); Serial.print("/"); Serial.println(micros() - t);
    }

public:
    SPIRAMVAllocP(VPtrSize ps, bool la, uint8_t cs, SerialRam::ESPISpeed s) :
        largeAddressing(la), chipSelect(cs), SPISpeed(s) { this->setPoolSize(ps); }
    SPIRAMVAllocP(VPtrSize ps) { this->setPoolSize(ps); }
    SPIRAMVAllocP(void) { } 
    ~SPIRAMVAllocP(void) { doStop(); }

    void setSettings(bool la, uint8_t cs, SerialRam::ESPISpeed s)
    {
        largeAddressing = la; chipSelect = cs; SPISpeed = s;
    }
};

typedef SPIRAMVAllocP<> SPIRAMVAlloc; 

struct SPIRamConfig
{
    bool largeAddressing; 
    uint32_t size; 
    uint8_t chipSelect; 
    SerialRam::ESPISpeed speed; 
};

template <const SPIRamConfig *SPIChips, size_t chipAmount, typename Properties=DefaultAllocProperties>
class MultiSPIRAMVAllocP : public VAlloc<Properties, MultiSPIRAMVAllocP<SPIChips, chipAmount, Properties> >
{
    SerialRam serialRAM[chipAmount];

    void doStart(void)
    {
        for (uint8_t i=0; i<chipAmount; ++i)
            serialRAM[i].begin(SPIChips[i].largeAddressing, SPIChips[i].chipSelect, SPIChips[i].speed);
    }

    void doStop(void)
    {
        for (uint8_t i=0; i<chipAmount; ++i)
            serialRAM[i].end();
    }

    void doRead(void *data, VPtrSize offset, VPtrSize size)
    {
//        const uint32_t t = micros();
        VPtrNum startptr = 0;
        for (uint8_t i=0; i<chipAmount; ++i)
        {
            const VPtrNum endptr = startptr + SPIChips[i].size;
            if (offset >= startptr && offset < endptr)
            {
                const VPtrNum p = offset - startptr; // address relative in this chip
                const VPtrSize sz = private_utils::minimal(size, SPIChips[i].size - p);
                serialRAM[i].read((char *)data, p, sz);

                if (sz == size)
                    break;

                size -= sz;
                data = (char *)data + sz;
                offset += sz;
            }
            startptr = endptr;
        }
//        Serial.print("read: "); Serial.print(size); Serial.print("/"); Serial.println(micros() - t);
    }

    void doWrite(const void *data, VPtrSize offset, VPtrSize size)
    {
//        const uint32_t t = micros();
        VPtrNum startptr = 0;
        for (uint8_t i=0; i<chipAmount; ++i)
        {
            const VPtrNum endptr = startptr + SPIChips[i].size;
            if (offset >= startptr && offset < endptr)
            {
                const VPtrNum p = offset - startptr; // address relative in this chip
                const VPtrSize sz = private_utils::minimal(size, SPIChips[i].size - p);
                serialRAM[i].write((const char *)data, p, sz);

                if (sz == size)
                    break;

                size -= sz;
                data = (const char *)data + sz;
                offset += sz;
            }
            startptr = endptr;
        }
//        Serial.print("write: "); Serial.print(size); Serial.print("/"); Serial.println(micros() - t);
    }

    using BaseVAlloc::setPoolSize;

public:
    MultiSPIRAMVAllocP(void)
    {
        uint32_t ps = 0;
        for (uint8_t i=0; i<chipAmount; ++i)
            ps += SPIChips[i].size;
        this->setPoolSize(ps);
    }
    ~MultiSPIRAMVAllocP(void) { doStop(); }
};

}

#endif // VIRTMEM_SPIRAM_ALLOC_H