pages.h

Go to the documentation of this file.

#pragma once
#include <Arduino.h>
#include "table3d.h"
 
uint8_t getPageCount(void); 
 
uint16_t getPageSize(byte pageNum  );
 
// These are the page numbers that the Tuner Studio serial protocol uses to transverse the different map and config pages.
#define veMapPage     2
#define veSetPage     1 //Note that this and the veMapPage were swapped in Feb 2019 as the 'algorithm' field must be declared in the ini before it's used in the fuel table
#define ignMapPage    3
#define ignSetPage    4//Config Page 2
#define afrMapPage    5
#define afrSetPage    6//Config Page 3
#define boostvvtPage  7
#define seqFuelPage   8
#define canbusPage    9//Config Page 9
#define warmupPage    10 //Config Page 10
#define fuelMap2Page  11
#define wmiMapPage    12
#define progOutsPage  13
#define ignMap2Page   14
#define boostvvtPage2 15
 
// ============================== Per-byte page access ==========================
 
byte getPageValue(  byte pageNum,       
                    uint16_t offset     
                    );
 
void setPageValue(  byte pageNum,       
                    uint16_t offset,    
                    byte value          
                    );
 
// ============================== Page Iteration ==========================
 
// A logical TS page is actually multiple in memory entities. Allow iteration
// over those entities.
 
// Type of entity
enum entity_type { 
    Raw,        // A block of memory
    Table,      // A 3D table
    NoEntity,   // No entity, but a valid offset
    End         // The offset was past any known entity for the page
};
 
struct entity_page_location_t {
    uint8_t page;   // The index of the page the entity belongs to
    uint8_t index;  // The sub-index of the item within the page
 
    constexpr entity_page_location_t(uint8_t pageNum, uint8_t pageSubIndex)
    : page(pageNum)
    , index(pageSubIndex)
    {        
    }
 
    bool operator==(const entity_page_location_t &other) const
    {
        return page==other.page
            && index==other.index;
    }
    bool operator!=(const entity_page_location_t &other) const
    {
        return !operator==(other);
    }
};
 
struct entity_page_address_t {
    uint16_t start; // The start position of the entity, in bytes, from the start of the page
    uint16_t size;  // Size of the entity in bytes
 
    entity_page_address_t(uint16_t base, uint16_t length)
    : start(base)
    , size(length)
    {        
    }
};
 
// A entity on a logical page.
struct page_iterator_t {
    void *pData;
    entity_type type;
    table_type_t table_key;
    entity_page_location_t location;
    entity_page_address_t address;
 
    page_iterator_t(entity_type theType, const entity_page_location_t &entityLocation, const entity_page_address_t &entityAddress)
    : pData(nullptr)
    , type(theType)
    , table_key(table_type_None)
    , location(entityLocation)    
    , address(entityAddress)
    {
    }
 
    page_iterator_t(void *pBuffer, const entity_page_location_t &entityLocation, const entity_page_address_t &entityAddress)
    : pData(pBuffer)
    , type(Raw)
    , table_key(table_type_None)
    , location(entityLocation)    
    , address(entityAddress)
    {
    }
    page_iterator_t(void *pTable, table_type_t key, const entity_page_location_t &entityLocation, const entity_page_address_t &entityAddress)
    : pData(pTable)
    , type(Table)
    , table_key(key)
    , location(entityLocation)    
    , address(entityAddress)
    {
    }
};
 
page_iterator_t page_begin(byte pageNum );
 
page_iterator_t advance(const page_iterator_t &it );
 
table_value_iterator rows_begin(const page_iterator_t &it);
 
table_axis_iterator x_begin(const page_iterator_t &it);
 
table_axis_iterator x_rbegin(const page_iterator_t &it);
 
table_axis_iterator y_begin(const page_iterator_t &it);