Big UI and navigation Rewrite

new navigation
add some color to the apps
redesign menus
new settings menu
new quick settings
code clean up
size reduction by converting navigation images to font
and more...

src/components/brightness/BrightnessController.cpp

@@ -1,5 +1,6 @@
 #include "BrightnessController.h"
 #include <hal/nrf_gpio.h>
+#include "displayapp/screens/Symbols.h"
 
 using namespace Pinetime::Controllers;
 
@@ -68,3 +69,30 @@ void BrightnessController::Restore() {
   Set(backupLevel);
 }
 
+void BrightnessController::Step() {
+  switch(level) {
+    case Levels::Low: Set(Levels::Medium); break;
+    case Levels::Medium: Set(Levels::High); break;
+    case Levels::High: Set(Levels::Low); break;
+    default: break;
+  }
+}
+
+const char* BrightnessController::GetIcon() {
+  switch(level) {    
+    case Levels::Medium: return Applications::Screens::Symbols::brightnessMedium;
+    case Levels::High: return Applications::Screens::Symbols::brightnessHigh;
+    default: break;
+  }
+  return Applications::Screens::Symbols::brightnessLow;
+}
+
+const char* BrightnessController::ToString() {
+  switch(level) {
+    case Levels::Off: return "Off";
+    case Levels::Low: return "Low";    
+    case Levels::Medium: return "Medium";    
+    case Levels::High: return "High";
+    default : return "???";
+  }
+}

src/components/brightness/BrightnessController.h

@@ -13,10 +13,14 @@ namespace Pinetime {
       Levels Level() const;
       void Lower();
       void Higher();
+      void Step();
 
       void Backup();
       void Restore();
 
+      const char* GetIcon();
+      const char* ToString();
+
     private:
       static constexpr uint8_t pinLcdBacklight1 = 14;
       static constexpr uint8_t pinLcdBacklight2 = 22;

src/components/motor/MotorController.cpp

@@ -7,6 +7,8 @@ APP_TIMER_DEF(vibTimer);
 
 using namespace Pinetime::Controllers;
 
+MotorController::MotorController( Controllers::Settings &settingsController ) : settingsController{settingsController} {}
+
 void MotorController::Init() {
     nrf_gpio_cfg_output(pinMotor);
     nrf_gpio_pin_set(pinMotor);
@@ -14,7 +16,10 @@ void MotorController::Init() {
     app_timer_create(&vibTimer, APP_TIMER_MODE_SINGLE_SHOT, vibrate);
 }
 
-void MotorController::SetDuration(uint8_t motorDuration) {    
+void MotorController::SetDuration(uint8_t motorDuration) {
+
+    if ( settingsController.GetVibrationStatus() == Controllers::Settings::Vibration::OFF ) return;
+    
     nrf_gpio_pin_clear(pinMotor);
     /* Start timer for motorDuration miliseconds and timer triggers vibrate() when it finishes*/
     app_timer_start(vibTimer, APP_TIMER_TICKS(motorDuration), NULL);

src/components/motor/MotorController.h

@@ -2,6 +2,7 @@
 
 #include <cstdint>
 #include "app_timer.h"
+#include "components/settings/Settings.h"
 
 namespace Pinetime {
   namespace Controllers {
@@ -9,10 +10,12 @@ namespace Pinetime {
 
     class MotorController {
       public:
+        MotorController( Controllers::Settings &settingsController );
         void Init();
         void SetDuration(uint8_t motorDuration);
 
       private:
+        Controllers::Settings& settingsController;
         static void vibrate(void * p_context);
     };
   }

src/components/settings/Settings.cpp

@@ -1,16 +1,114 @@
 #include "Settings.h"
+#include <cstdlib>
+#include <cstring>
 
 using namespace Pinetime::Controllers;
 
+struct SettingsHeader {
+    uint8_t isActive; // 0xF1 = Block is active, 0xF0 = Block is inactive
+    uint16_t version; // Current version, to verify if the saved data is for the current Version
+};
+
+#define HEADER_SIZE sizeof(SettingsHeader)
+
+
+Settings::Settings( Pinetime::Drivers::SpiNorFlash &spiNorFlash ) : spiNorFlash{spiNorFlash} {}
 
-// TODO (team): 
-// Read and write the settings to Flash
-//
 void Settings::Init() {
-    // default Clock face
-    clockFace = 0;
 
-    clockType = ClockType::H24;
+    // Load default settings from Flash
+    LoadSettingsFromFlash();
 
 }
 
+void Settings::SaveSettings() {
+
+    // verify if is necessary to save
+    if ( settingsChanged ) {
+        SaveSettingsToFlash();
+    }
+    settingsChanged = false;
+}
+
+
+bool Settings::FindHeader() {
+    SettingsHeader settingsHeader;
+    uint8_t bufferHead[sizeof(settingsHeader)];
+
+    for (uint8_t block = 0; block < 10; block++) {
+    
+        spiNorFlash.Read( settingsBaseAddr + (block * 0x1000), bufferHead, sizeof(settingsHeader) );
+        std::memcpy(&settingsHeader, bufferHead, sizeof(settingsHeader));
+        if ( settingsHeader.isActive == 0xF1 && settingsHeader.version == settingsVersion ) {
+            settingsFlashBlock = block;
+            return true;
+        }
+    }
+    return false;
+}
+
+void Settings::ReadSettingsData() {
+    uint8_t bufferSettings[sizeof(settings)];
+    spiNorFlash.Read( settingsBaseAddr + (settingsFlashBlock * 0x1000) + HEADER_SIZE, bufferSettings, sizeof(settings) );
+    std::memcpy(&settings, bufferSettings, sizeof(settings));
+}
+
+void Settings::EraseBlock() {
+
+    spiNorFlash.SectorErase(settingsBaseAddr + (settingsFlashBlock * 0x1000));
+}
+
+void Settings::SetHeader( bool state ) {
+    SettingsHeader settingsHeader;
+    uint8_t bufferHead[sizeof(settingsHeader)];
+    settingsHeader.isActive = state ? 0xF1 : 0xF0;
+    settingsHeader.version = settingsVersion;
+
+    std::memcpy(bufferHead, &settingsHeader, sizeof(settingsHeader));
+    spiNorFlash.Write(settingsBaseAddr + (settingsFlashBlock * 0x1000), bufferHead, sizeof(settingsHeader));
+
+}
+
+void Settings::SaveSettingsData() {
+    uint8_t bufferSettings[sizeof(settings)];
+    std::memcpy(bufferSettings, &settings, sizeof(settings));
+    spiNorFlash.Write(settingsBaseAddr + (settingsFlashBlock * 0x1000) + HEADER_SIZE, bufferSettings, sizeof(settings));
+}
+
+void Settings::LoadSettingsFromFlash() {
+
+    if ( settingsFlashBlock == 99 ) {
+        // Find current Block, if can't find use default settings and set block to 0 ans save !
+        if ( FindHeader() ) {
+            ReadSettingsData();
+        } else {
+            SaveSettingsToFlash();
+        }
+    } else {
+        // Read Settings from flash...
+        // never used :)
+        ReadSettingsData();
+    }
+    
+}
+
+void Settings::SaveSettingsToFlash() {
+    
+    // calculate where to save...
+    // mark current to inactive
+    // erase the new location and save
+    // set settingsFlashBlock
+
+    // if first time hever, only saves to block 0 and set settingsFlashBlock
+
+    if ( settingsFlashBlock != 99 ) {
+        SetHeader( false );
+    }
+
+    settingsFlashBlock++;
+    if ( settingsFlashBlock > 9 ) settingsFlashBlock = 0;
+
+    EraseBlock();
+    SetHeader( true );
+    SaveSettingsData();
+}

src/components/settings/Settings.h

@@ -1,29 +1,104 @@
 #pragma once
 #include <cstdint>
+#include "components/datetime/DateTimeController.h"
+#include "components/brightness/BrightnessController.h"
+#include "drivers/SpiNorFlash.h"
+#include "drivers/Cst816s.h"
 
 namespace Pinetime {
   namespace Controllers {
     class Settings {
       public:
         enum class ClockType {H24, H12};
+        enum class Vibration {ON, OFF};
+        enum class WakeUpMode {None, SingleTap, DoubleTap, RaiseWrist};
+
+        Settings( Pinetime::Drivers::SpiNorFlash &spiNorFlash );
 
         void Init();
+        void SaveSettings();
 
-        void SetClockFace( uint8_t face ) { clockFace = face; };
-        uint8_t GetClockFace() { return clockFace; };
+        void SetClockFace( uint8_t face ) {
+          if ( face != settings.clockFace ) settingsChanged = true;
+          settings.clockFace = face; 
+        };
+        uint8_t GetClockFace() const { return settings.clockFace; };
 
         void SetAppMenu( uint8_t menu ) { appMenu = menu; };
         uint8_t GetAppMenu() { return appMenu; };
 
-        void SetClockType( ClockType clocktype ) { clockType = clocktype; };
-        ClockType GetClockType() { return clockType; };
+        void SetSettingsMenu( uint8_t menu ) { settingsMenu = menu; };
+        uint8_t GetSettingsMenu() const { return settingsMenu; };
 
+        void SetClockType( ClockType clocktype ) { 
+          if ( clocktype != settings.clockType ) settingsChanged = true;
+          settings.clockType = clocktype; 
+        };
+        ClockType GetClockType() const { return settings.clockType; };
+
+        void SetVibrationStatus( Vibration status ) { 
+          if ( status != settings.vibrationStatus ) settingsChanged = true;
+          settings.vibrationStatus = status; 
+        };
+        Vibration GetVibrationStatus() const { return settings.vibrationStatus; };
+
+        void SetScreenTimeOut( uint32_t timeout ) { 
+          if ( timeout != settings.screenTimeOut ) settingsChanged = true;
+          settings.screenTimeOut = timeout; 
+        };
+        uint32_t GetScreenTimeOut() const { return settings.screenTimeOut; };        
+
+        void setWakeUpMode( WakeUpMode wakeUp ) { 
+          if ( wakeUp != settings.wakeUpMode ) settingsChanged = true;
+          settings.wakeUpMode = wakeUp; 
+        };
+        WakeUpMode getWakeUpMode() const { return settings.wakeUpMode; };
+
+        void SetBrightness( Controllers::BrightnessController::Levels level ) { 
+          if ( level != settings.brightLevel ) settingsChanged = true;
+          settings.brightLevel = level; 
+        };
+        Controllers::BrightnessController::Levels GetBrightness() const { return settings.brightLevel; };
 
       private:
-        uint8_t clockFace = 0;
-        uint8_t appMenu = 0;
 
-        ClockType clockType = ClockType::H24;
+        Pinetime::Drivers::SpiNorFlash& spiNorFlash;        
+        struct SettingsData {
+
+          ClockType clockType = ClockType::H24;
+          Vibration vibrationStatus = Vibration::ON;
+
+          uint8_t clockFace = 0;
+
+          uint32_t stepsGoal = 1000;
+          uint32_t screenTimeOut = 15000;
+
+          WakeUpMode wakeUpMode = WakeUpMode::None;
+
+          Controllers::BrightnessController::Levels brightLevel = Controllers::BrightnessController::Levels::Medium;
+
+        };
+
+        SettingsData settings;
+        bool settingsChanged = false;
+
+        uint8_t appMenu = 0;
+        uint8_t settingsMenu = 0;
+
+        // There are 10 blocks of reserved flash to save settings
+        // to minimize wear, the recording is done in a rotating way by the 10 blocks
+        uint8_t settingsFlashBlock = 99; // default to indicate it needs to find the active block
+
+        static constexpr uint32_t settingsBaseAddr =  0x3F6000; // Flash Settings Location
+        static constexpr uint16_t settingsVersion =  0x0100; // Flash Settings Version
+
+        bool FindHeader();
+        void ReadSettingsData();
+        void EraseBlock();
+        void SetHeader( bool state );
+        void SaveSettingsData();
+        void LoadSettingsFromFlash();
+        void SaveSettingsToFlash();
 
     };
   }