Page.* SonarQube fixes (speeduino#1422)

adbancroft · web-flow · commit b829e51b4f3d · 2026-02-22T13:34:52.000-06:00
* Replace #define with constexpr

* Change entity_type to an enum class.

* Apply 'hidden friend' idiom to entity_page_location_t operators.

* "static inline constexpr" -&gt; "static constexpr"

* Remove getPageCount(), replace with MAX_PAGE_NUM

* byte -&gt; uint8_t
diff --git a/speeduino/comms_legacy.cpp b/speeduino/comms_legacy.cpp
@@ -930,15 +930,15 @@ namespace {
   {
     switch (entity.type)
     {
-    case Raw:
+    case EntityType::Raw:
       return send_raw_entity(entity);
       break;
 
-    case Table:
+    case EntityType::Table:
       return send_table_entity(entity);
       break;
     
-    case NoEntity:
+    case EntityType::NoEntity:
       // No-op
       break;
 
@@ -960,7 +960,7 @@ void sendPage(void)
 {
   page_iterator_t entity = page_begin(currentPage);
 
-  while (entity.type!=End)
+  while (entity.type!=EntityType::End)
   {
     send_entity(entity);
     entity = advance(entity);
diff --git a/speeduino/page_crc.cpp b/speeduino/page_crc.cpp
@@ -2,7 +2,7 @@
 #include "page_crc.h"
 #include "pages.h"
 
-uint32_t __attribute__((optimize("Os"))) calculatePageCRC32(byte pageNum)
+uint32_t __attribute__((optimize("Os"))) calculatePageCRC32(uint8_t pageNum)
 {
     FastCRC32 crcCalc;
     
diff --git a/speeduino/page_crc.h b/speeduino/page_crc.h
@@ -4,4 +4,4 @@
 /*
  * Calculates and returns the CRC32 value of a given page of memory
  */
-uint32_t calculatePageCRC32(byte pageNum /**< [in] The page number to compute CRC for. */);
+uint32_t calculatePageCRC32(uint8_t pageNum /**< [in] The page number to compute CRC for. */);
diff --git a/speeduino/pages.cpp b/speeduino/pages.cpp
@@ -33,17 +33,17 @@
 // calling context.
 
 template <class table_t>
-static inline constexpr uint16_t get_table_value_end(void)
+static constexpr uint16_t get_table_value_end(void)
 {
   return table_t::xaxis_t::length*table_t::yaxis_t::length;
 }
 template <class table_t>
-static inline constexpr uint16_t get_table_axisx_end(void)
+static constexpr uint16_t get_table_axisx_end(void)
 {
   return get_table_value_end<table_t>()+table_t::xaxis_t::length;
 }
 template <class table_t>
-static inline constexpr uint16_t get_table_axisy_end(const table_t *table)
+static constexpr uint16_t get_table_axisy_end(const table_t *table)
 {
   UNUSED(table);
   return get_table_axisx_end<table_t>()+table_t::yaxis_t::length;
@@ -194,11 +194,11 @@ static inline byte get_table_value(const page_iterator_t &entity, uint16_t offse
 
 byte getEntityValue(const page_iterator_t &entity, uint16_t offset)
 {
-  if (Raw==entity.type)
+  if (EntityType::Raw==entity.type)
   {
     return get_raw_location(entity, offset);
   }
-  if (Table==entity.type)
+  if (EntityType::Table==entity.type)
   {
     return get_table_value(entity, offset);
   }
@@ -224,11 +224,11 @@ static inline bool set_table_value(page_iterator_t &entity, uint16_t offset, byt
 
 bool setEntityValue(page_iterator_t &entity, uint16_t offset, byte value)
 {    
-  if (Raw==entity.type)
+  if (EntityType::Raw==entity.type)
   {
     return set_raw_location(entity, offset, value);
   }
-  else if (Table==entity.type)
+  else if (EntityType::Table==entity.type)
   {
     return set_table_value(entity, offset, value);
   }
@@ -252,7 +252,7 @@ void nextEntity(page_iterator_t &entity, uint16_t nextBlockSize)
 template <class table_t>
 static void checkIsInTable(page_iterator_t &result, table_t *pTable, uint16_t offset)
 {
-  if (result.type==End)
+  if (result.type==EntityType::End)
   {
     nextEntity(result, get_table_axisy_end(pTable));
     if (result.address.isOffsetInEntity(offset)) 
@@ -266,7 +266,7 @@ static void checkIsInTable(page_iterator_t &result, table_t *pTable, uint16_t of
 
 static void checkIsInRaw(page_iterator_t &result, void *pEntity, uint16_t entitySize, uint16_t offset)
 {
-  if (result.type==End)
+  if (result.type==EntityType::End)
   {
     nextEntity(result, entitySize);
     if (result.address.isOffsetInEntity(offset)) 
@@ -280,7 +280,7 @@ static void checkIsInRaw(page_iterator_t &result, void *pEntity, uint16_t entity
 
 static void checkIsInEmpty(page_iterator_t &result, uint16_t entitySize, uint16_t offset)
 {
-  if (result.type==End)
+  if (result.type==EntityType::End)
   {
     nextEntity(result, entitySize);
     if (result.address.isOffsetInEntity(offset)) 
@@ -299,7 +299,7 @@ static void checkIsInEmpty(page_iterator_t &result, uint16_t entitySize, uint16_
 static page_iterator_t map_page_offset_to_entity(uint8_t pageNumber, uint16_t offset)
 {
   // This is mutated by the checkIsIn* functions to return the entity that matches the offset
-  page_iterator_t result( End, // Signal that no entity has been found yet
+  page_iterator_t result( EntityType::End, // Signal that no entity has been found yet
                           entity_page_location_t(pageNumber, (uint8_t)-1 /* Deliberate, so we can increment index AND address as one operation */), 
                           entity_page_address_t(0U, 0U));
 
@@ -384,7 +384,7 @@ static page_iterator_t map_page_offset_to_entity(uint8_t pageNumber, uint16_t of
   }
 
   // Nothing matched, so we are at the end of the known entities for the page.
-  if (result.type==End)
+  if (result.type==EntityType::End)
   {
     nextEntity(result, 0U);
   }
@@ -395,12 +395,7 @@ static page_iterator_t map_page_offset_to_entity(uint8_t pageNumber, uint16_t of
 
 // ====================================== External functions  ====================================
 
-uint8_t getPageCount(void)
-{
-  return 16U;
-}
-
-uint16_t getPageSize(byte pageNum)
+uint16_t getPageSize(uint8_t pageNum)
 {
   page_iterator_t entity = map_page_offset_to_entity(pageNum, UINT16_MAX);
   return entity.address.start + entity.address.size;
@@ -411,14 +406,14 @@ static inline uint16_t pageOffsetToEntityOffset(const page_iterator_t &entity, u
   return pageOffset-entity.address.start;
 }
 
-bool setPageValue(byte pageNum, uint16_t offset, byte value)
+bool setPageValue(uint8_t pageNum, uint16_t offset, byte value)
 {
   page_iterator_t entity = map_page_offset_to_entity(pageNum, offset);
 
   return setEntityValue(entity, pageOffsetToEntityOffset(entity, offset), value);
 }
 
-byte getPageValue(byte pageNum, uint16_t offset)
+byte getPageValue(uint8_t pageNum, uint16_t offset)
 {
   page_iterator_t entity = map_page_offset_to_entity(pageNum, offset);
 
@@ -429,7 +424,7 @@ byte getPageValue(byte pageNum, uint16_t offset)
 // No need to have coverage on simple wrappers
 
 // Support iteration over a pages entities.
-page_iterator_t page_begin(byte pageNum)
+page_iterator_t page_begin(uint8_t pageNum)
 {
   return map_page_offset_to_entity(pageNum, 0U);
 }
diff --git a/speeduino/pages.h b/speeduino/pages.h
@@ -2,38 +2,34 @@
 #include <Arduino.h>
 #include "table3d.h"
 
-/**
- * Page count, as defined in the INI file
- */
-uint8_t getPageCount(void); 
-
 /**
  * Page size in bytes
  */
-uint16_t getPageSize(byte pageNum /**< [in] The page number */ );
+uint16_t getPageSize(uint8_t pageNum /**< [in] The page number */ );
 
 // 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
-#define MAX_PAGE_NUM  (boostvvtPage2+1U)
+constexpr uint8_t veMapPage     = 2;
+constexpr uint8_t 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
+constexpr uint8_t ignMapPage    = 3;
+constexpr uint8_t ignSetPage    = 4;
+constexpr uint8_t afrMapPage    = 5;
+constexpr uint8_t afrSetPage    = 6;
+constexpr uint8_t boostvvtPage  = 7;
+constexpr uint8_t seqFuelPage   = 8;
+constexpr uint8_t canbusPage    = 9;
+constexpr uint8_t warmupPage    = 10;
+constexpr uint8_t fuelMap2Page  = 11;
+constexpr uint8_t wmiMapPage    = 12;
+constexpr uint8_t progOutsPage  = 13;
+constexpr uint8_t ignMap2Page   = 14;
+constexpr uint8_t boostvvtPage2 = 15;
+constexpr uint8_t MIN_PAGE_NUM  = veSetPage;
+constexpr uint8_t MAX_PAGE_NUM  = (boostvvtPage2+1U);
 
 // ============================== Per-byte page access ==========================
 
 /** @brief Gets a single value from a page, with data aligned as per the ini file */
-byte getPageValue(  byte pageNum,       /**< [in] The page number to retrieve data from. */
+byte getPageValue(  uint8_t pageNum,       /**< [in] The page number to retrieve data from. */
                     uint16_t offset     /**< [in] The address in the page that should be returned. This is as per the page definition in the ini. */
                     );
 
@@ -42,7 +38,7 @@ byte getPageValue(  byte pageNum,       /**< [in] The page number to retrieve da
  * 
  * @returns true if value set, false otherwise
  */
-bool setPageValue(  byte pageNum,       /**< [in] The page number to update. */
+bool setPageValue(  uint8_t pageNum,       /**< [in] The page number to update. */
                     uint16_t offset,    /**< [in] The offset within the page.  */
                     byte value          /**< [in] The new value */
                     );
@@ -54,7 +50,7 @@ bool setPageValue(  byte pageNum,       /**< [in] The page number to update. */
 // over those entities.
 
 // Type of entity
-enum entity_type { 
+enum class EntityType : uint8_t { 
     Raw,        // A block of memory
     Table,      // A 3D table
     NoEntity,   // No entity, but a valid offset
@@ -72,15 +68,16 @@ struct entity_page_location_t {
     {        
     }
 
-    bool operator==(const entity_page_location_t &other) const
+    friend bool operator==(const entity_page_location_t &lhs, const entity_page_location_t &rhs)
     {
-        return page==other.page
-            && index==other.index;
+        return lhs.page==rhs.page
+            && lhs.index==rhs.index;
     }
-    bool operator!=(const entity_page_location_t &other) const
+
+    friend bool operator!=(const entity_page_location_t &lhs, const entity_page_location_t &rhs)
     {
-        return !operator==(other);
-    }
+        return !(lhs==rhs);
+    }    
 };
 
 /** @brief  Position and size of an entity within a page */
@@ -114,12 +111,12 @@ struct entity_page_address_t {
 // A entity on a logical page.
 struct page_iterator_t {
     void *pData = nullptr;
-    entity_type type;
+    EntityType type;
     table_type_t table_key = table_type_None;
     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)
+    page_iterator_t(EntityType theType, const entity_page_location_t &entityLocation, const entity_page_address_t &entityAddress)
     : type(theType)
     , location(entityLocation)    
     , address(entityAddress)
@@ -129,21 +126,21 @@ struct page_iterator_t {
     void setNoEntity(void)
     {
         pData = nullptr;
-        type = NoEntity;
+        type = EntityType::NoEntity;
         table_key = table_type_None;
     }
 
     void setTable(void *pTable, table_type_t key)
     {
         pData = pTable;
-        type = Table;
+        type = EntityType::Table;
         table_key = key;
     }
 
     void setRaw(void *pBuffer)
     {
         pData = pBuffer;
-        type = Raw;
+        type = EntityType::Raw;
         table_key = table_type_None;
     }
 };
@@ -168,7 +165,7 @@ bool setEntityValue(page_iterator_t &entity,  /**< [in] The entity to update */
  * Initiates iteration over a pages entities.
  * Test `entity.type==End` to determine the end of the page.
  */
-page_iterator_t page_begin(byte pageNum /**< [in] The page number to iterate over. */);
+page_iterator_t page_begin(uint8_t pageNum /**< [in] The page number to iterate over. */);
 
 /**
  * Moves the iterator to the next sub-entity on the page
diff --git a/speeduino/storage.cpp b/speeduino/storage.cpp
@@ -44,14 +44,13 @@ bool isEepromWritePending(void)
  */
 void writeAllConfig(void)
 {
-  uint8_t pageCount = getPageCount();
-  uint8_t page = 1U;
+  uint8_t page = MIN_PAGE_NUM;
   writeConfig(page);
-  page = page + 1;
-  while (page<pageCount && !isEepromWritePending())
+  ++page;
+  while (page<MAX_PAGE_NUM && !isEepromWritePending())
   {
     writeConfig(page);
-    page = page + 1;
+    ++page;
   }
 }
 
@@ -303,12 +302,12 @@ void writeConfig(uint8_t pageNum)
  */
 void resetConfigPages(void)
 {
-  for (uint8_t page=1; page<getPageCount(); ++page)
+  for (uint8_t page=MIN_PAGE_NUM; page<MAX_PAGE_NUM; ++page)
   {
     page_iterator_t entity = page_begin(page);
-    while (entity.type!=End)
+    while (entity.type!=EntityType::End)
     {
-      if (entity.type==Raw)
+      if (entity.type==EntityType::Raw)
       {
         memset(entity.pData, 0, entity.address.size);
       }
@@ -501,7 +500,7 @@ void writeCalibrationPage(uint8_t pageNum)
 
 static eeprom_address_t compute_crc_address(uint8_t pageNum)
 {
-  return EEPROM_LAST_BARO-((getPageCount() - pageNum)*sizeof(uint32_t));
+  return EEPROM_LAST_BARO-((MAX_PAGE_NUM - pageNum)*sizeof(uint32_t));
 }
 
 /** Write CRC32 checksum to EEPROM.
diff --git a/test/test_pages/test_page.cpp b/test/test_pages/test_page.cpp

Original file line number	Diff line number	Diff line change
`@@ -930,15 +930,15 @@ namespace {`
`930`	`930`	`{`
`931`	`931`	`switch (entity.type)`
`932`	`932`	`{`
`933`		`- case Raw:`
	`933`	`+ case EntityType::Raw:`
`934`	`934`	`return send_raw_entity(entity);`
`935`	`935`	`break;`
`936`	`936`
`937`		`- case Table:`
	`937`	`+ case EntityType::Table:`
`938`	`938`	`return send_table_entity(entity);`
`939`	`939`	`break;`
`940`	`940`
`941`		`- case NoEntity:`
	`941`	`+ case EntityType::NoEntity:`
`942`	`942`	`// No-op`
`943`	`943`	`break;`
`944`	`944`
`@@ -960,7 +960,7 @@ void sendPage(void)`
`960`	`960`	`{`
`961`	`961`	`page_iterator_t entity = page_begin(currentPage);`
`962`	`962`
`963`		`- while (entity.type!=End)`
	`963`	`+ while (entity.type!=EntityType::End)`
`964`	`964`	`{`
`965`	`965`	`send_entity(entity);`
`966`	`966`	`entity = advance(entity);`
Original file line number	Diff line number	Diff line change
`@@ -2,7 +2,7 @@`
`2`	`2`	`#include "page_crc.h"`
`3`	`3`	`#include "pages.h"`
`4`	`4`
`5`		`-uint32_t __attribute__((optimize("Os"))) calculatePageCRC32(byte pageNum)`
	`5`	`+uint32_t __attribute__((optimize("Os"))) calculatePageCRC32(uint8_t pageNum)`
`6`	`6`	`{`
`7`	`7`	`FastCRC32 crcCalc;`
`8`	`8`
Original file line number	Diff line number	Diff line change
`@@ -33,17 +33,17 @@`
`33`	`33`	`// calling context.`
`34`	`34`
`35`	`35`	`template <class table_t>`
`36`		`-static inline constexpr uint16_t get_table_value_end(void)`
	`36`	`+static constexpr uint16_t get_table_value_end(void)`
`37`	`37`	`{`
`38`	`38`	`return table_t::xaxis_t::length*table_t::yaxis_t::length;`
`39`	`39`	`}`
`40`	`40`	`template <class table_t>`
`41`		`-static inline constexpr uint16_t get_table_axisx_end(void)`
	`41`	`+static constexpr uint16_t get_table_axisx_end(void)`
`42`	`42`	`{`
`43`	`43`	`return get_table_value_end<table_t>()+table_t::xaxis_t::length;`
`44`	`44`	`}`
`45`	`45`	`template <class table_t>`
`46`		`-static inline constexpr uint16_t get_table_axisy_end(const table_t *table)`
	`46`	`+static constexpr uint16_t get_table_axisy_end(const table_t *table)`
`47`	`47`	`{`
`48`	`48`	`UNUSED(table);`
`49`	`49`	`return get_table_axisx_end<table_t>()+table_t::yaxis_t::length;`
`@@ -194,11 +194,11 @@ static inline byte get_table_value(const page_iterator_t &entity, uint16_t offse`
`194`	`194`
`195`	`195`	`byte getEntityValue(const page_iterator_t &entity, uint16_t offset)`
`196`	`196`	`{`
`197`		`- if (Raw==entity.type)`
	`197`	`+ if (EntityType::Raw==entity.type)`
`198`	`198`	`{`
`199`	`199`	`return get_raw_location(entity, offset);`
`200`	`200`	`}`
`201`		`- if (Table==entity.type)`
	`201`	`+ if (EntityType::Table==entity.type)`
`202`	`202`	`{`
`203`	`203`	`return get_table_value(entity, offset);`
`204`	`204`	`}`
`@@ -224,11 +224,11 @@ static inline bool set_table_value(page_iterator_t &entity, uint16_t offset, byt`
`224`	`224`
`225`	`225`	`bool setEntityValue(page_iterator_t &entity, uint16_t offset, byte value)`
`226`	`226`	`{`
`227`		`- if (Raw==entity.type)`
	`227`	`+ if (EntityType::Raw==entity.type)`
`228`	`228`	`{`
`229`	`229`	`return set_raw_location(entity, offset, value);`
`230`	`230`	`}`
`231`		`- else if (Table==entity.type)`
	`231`	`+ else if (EntityType::Table==entity.type)`
`232`	`232`	`{`
`233`	`233`	`return set_table_value(entity, offset, value);`
`234`	`234`	`}`
`@@ -252,7 +252,7 @@ void nextEntity(page_iterator_t &entity, uint16_t nextBlockSize)`
`252`	`252`	`template <class table_t>`
`253`	`253`	`static void checkIsInTable(page_iterator_t &result, table_t *pTable, uint16_t offset)`
`254`	`254`	`{`
`255`		`- if (result.type==End)`
	`255`	`+ if (result.type==EntityType::End)`
`256`	`256`	`{`
`257`	`257`	`nextEntity(result, get_table_axisy_end(pTable));`
`258`	`258`	`if (result.address.isOffsetInEntity(offset))`
`@@ -266,7 +266,7 @@ static void checkIsInTable(page_iterator_t &result, table_t *pTable, uint16_t of`
`266`	`266`
`267`	`267`	`static void checkIsInRaw(page_iterator_t &result, void *pEntity, uint16_t entitySize, uint16_t offset)`
`268`	`268`	`{`
`269`		`- if (result.type==End)`
	`269`	`+ if (result.type==EntityType::End)`
`270`	`270`	`{`
`271`	`271`	`nextEntity(result, entitySize);`
`272`	`272`	`if (result.address.isOffsetInEntity(offset))`
`@@ -280,7 +280,7 @@ static void checkIsInRaw(page_iterator_t &result, void *pEntity, uint16_t entity`
`280`	`280`
`281`	`281`	`static void checkIsInEmpty(page_iterator_t &result, uint16_t entitySize, uint16_t offset)`
`282`	`282`	`{`
`283`		`- if (result.type==End)`
	`283`	`+ if (result.type==EntityType::End)`
`284`	`284`	`{`
`285`	`285`	`nextEntity(result, entitySize);`
`286`	`286`	`if (result.address.isOffsetInEntity(offset))`
`@@ -299,7 +299,7 @@ static void checkIsInEmpty(page_iterator_t &result, uint16_t entitySize, uint16_`
`299`	`299`	`static page_iterator_t map_page_offset_to_entity(uint8_t pageNumber, uint16_t offset)`
`300`	`300`	`{`
`301`	`301`	`// This is mutated by the checkIsIn* functions to return the entity that matches the offset`
`302`		`- page_iterator_t result( End, // Signal that no entity has been found yet`
	`302`	`+ page_iterator_t result( EntityType::End, // Signal that no entity has been found yet`
`303`	`303`	`entity_page_location_t(pageNumber, (uint8_t)-1 /* Deliberate, so we can increment index AND address as one operation */),`
`304`	`304`	`entity_page_address_t(0U, 0U));`
`305`	`305`
`@@ -384,7 +384,7 @@ static page_iterator_t map_page_offset_to_entity(uint8_t pageNumber, uint16_t of`
`384`	`384`	`}`
`385`	`385`
`386`	`386`	`// Nothing matched, so we are at the end of the known entities for the page.`
`387`		`- if (result.type==End)`
	`387`	`+ if (result.type==EntityType::End)`
`388`	`388`	`{`
`389`	`389`	`nextEntity(result, 0U);`
`390`	`390`	`}`
`@@ -395,12 +395,7 @@ static page_iterator_t map_page_offset_to_entity(uint8_t pageNumber, uint16_t of`
`395`	`395`
`396`	`396`	`// ====================================== External functions ====================================`
`397`	`397`
`398`		`-uint8_t getPageCount(void)`
`399`		`-{`
`400`		`- return 16U;`
`401`		`-}`
`402`		`-`
`403`		`-uint16_t getPageSize(byte pageNum)`
	`398`	`+uint16_t getPageSize(uint8_t pageNum)`
`404`	`399`	`{`
`405`	`400`	`page_iterator_t entity = map_page_offset_to_entity(pageNum, UINT16_MAX);`
`406`	`401`	`return entity.address.start + entity.address.size;`
`@@ -411,14 +406,14 @@ static inline uint16_t pageOffsetToEntityOffset(const page_iterator_t &entity, u`
`411`	`406`	`return pageOffset-entity.address.start;`
`412`	`407`	`}`
`413`	`408`
`414`		`-bool setPageValue(byte pageNum, uint16_t offset, byte value)`
	`409`	`+bool setPageValue(uint8_t pageNum, uint16_t offset, byte value)`
`415`	`410`	`{`
`416`	`411`	`page_iterator_t entity = map_page_offset_to_entity(pageNum, offset);`
`417`	`412`
`418`	`413`	`return setEntityValue(entity, pageOffsetToEntityOffset(entity, offset), value);`
`419`	`414`	`}`
`420`	`415`
`421`		`-byte getPageValue(byte pageNum, uint16_t offset)`
	`416`	`+byte getPageValue(uint8_t pageNum, uint16_t offset)`
`422`	`417`	`{`
`423`	`418`	`page_iterator_t entity = map_page_offset_to_entity(pageNum, offset);`
`424`	`419`
`@@ -429,7 +424,7 @@ byte getPageValue(byte pageNum, uint16_t offset)`
`429`	`424`	`// No need to have coverage on simple wrappers`
`430`	`425`
`431`	`426`	`// Support iteration over a pages entities.`
`432`		`-page_iterator_t page_begin(byte pageNum)`
	`427`	`+page_iterator_t page_begin(uint8_t pageNum)`
`433`	`428`	`{`
`434`	`429`	`return map_page_offset_to_entity(pageNum, 0U);`
`435`	`430`	`}`
Original file line number	Diff line number	Diff line change
`@@ -44,14 +44,13 @@ bool isEepromWritePending(void)`
`44`	`44`	`*/`
`45`	`45`	`void writeAllConfig(void)`
`46`	`46`	`{`
`47`		`- uint8_t pageCount = getPageCount();`
`48`		`- uint8_t page = 1U;`
	`47`	`+ uint8_t page = MIN_PAGE_NUM;`
`49`	`48`	`writeConfig(page);`
`50`		`- page = page + 1;`
`51`		`- while (page<pageCount && !isEepromWritePending())`
	`49`	`+ ++page;`
	`50`	`+ while (page<MAX_PAGE_NUM && !isEepromWritePending())`
`52`	`51`	`{`
`53`	`52`	`writeConfig(page);`
`54`		`- page = page + 1;`
	`53`	`+ ++page;`
`55`	`54`	`}`
`56`	`55`	`}`
`57`	`56`
`@@ -303,12 +302,12 @@ void writeConfig(uint8_t pageNum)`
`303`	`302`	`*/`
`304`	`303`	`void resetConfigPages(void)`
`305`	`304`	`{`
`306`		`- for (uint8_t page=1; page<getPageCount(); ++page)`
	`305`	`+ for (uint8_t page=MIN_PAGE_NUM; page<MAX_PAGE_NUM; ++page)`
`307`	`306`	`{`
`308`	`307`	`page_iterator_t entity = page_begin(page);`
`309`		`- while (entity.type!=End)`
	`308`	`+ while (entity.type!=EntityType::End)`
`310`	`309`	`{`
`311`		`- if (entity.type==Raw)`
	`310`	`+ if (entity.type==EntityType::Raw)`
`312`	`311`	`{`
`313`	`312`	`memset(entity.pData, 0, entity.address.size);`
`314`	`313`	`}`
`@@ -501,7 +500,7 @@ void writeCalibrationPage(uint8_t pageNum)`
`501`	`500`
`502`	`501`	`static eeprom_address_t compute_crc_address(uint8_t pageNum)`
`503`	`502`	`{`
`504`		`- return EEPROM_LAST_BARO-((getPageCount() - pageNum)*sizeof(uint32_t));`
	`503`	`+ return EEPROM_LAST_BARO-((MAX_PAGE_NUM - pageNum)*sizeof(uint32_t));`
`505`	`504`	`}`
`506`	`505`
`507`	`506`	`/** Write CRC32 checksum to EEPROM.`