From 7f9cc51b050e1034b573e37484f7afe29c370d81 Mon Sep 17 00:00:00 2001
From: Jean-François Milants <jf@codingfield.com>
Date: Sun, 6 Jun 2021 15:56:03 +0200
Subject: Initialize SystemTask, DisplayApp and HeartRateTask as global static
 variable instead of variables on the heap. We don't need them on the heap as
 we know their size at build time, it'll reduce memory fragmentation and it'll
 make memory analysis easier.

---
 src/systemtask/SystemTask.cpp | 75 +++++++++++++++++++++----------------------
 1 file changed, 37 insertions(+), 38 deletions(-)

(limited to 'src/systemtask/SystemTask.cpp')

diff --git a/src/systemtask/SystemTask.cpp b/src/systemtask/SystemTask.cpp
index 58377764..be484bb4 100644
--- a/src/systemtask/SystemTask.cpp
+++ b/src/systemtask/SystemTask.cpp
@@ -42,10 +42,18 @@ SystemTask::SystemTask(Drivers::SpiMaster& spi,
                        Components::LittleVgl& lvgl,
                        Controllers::Battery& batteryController,
                        Controllers::Ble& bleController,
+                       Controllers::DateTime& dateTimeController,
+                       Controllers::TimerController& timerController,
+                       Drivers::Watchdog& watchdog,
+                       Pinetime::Controllers::NotificationManager& notificationManager,
                        Pinetime::Controllers::MotorController& motorController,
                        Pinetime::Drivers::Hrs3300& heartRateSensor,
+                       Pinetime::Controllers::MotionController& motionController,
                        Pinetime::Drivers::Bma421& motionSensor,
-                       Controllers::Settings& settingsController)
+                       Controllers::Settings& settingsController,
+                       Pinetime::Controllers::HeartRateController& heartRateController,
+                       Pinetime::Applications::DisplayApp& displayApp,
+                       Pinetime::Applications::HeartRateTask& heartRateApp)
   : spi {spi},
     lcd {lcd},
     spiNorFlash {spiNorFlash},
@@ -53,17 +61,20 @@ SystemTask::SystemTask(Drivers::SpiMaster& spi,
     touchPanel {touchPanel},
     lvgl {lvgl},
     batteryController {batteryController},
-    heartRateController {*this},
     bleController {bleController},
-    dateTimeController {*this},
-    timerController {*this},
-    watchdog {},
-    watchdogView {watchdog},
+    dateTimeController {dateTimeController},
+    timerController {timerController},
+    watchdog {watchdog},
+    notificationManager{notificationManager},
     motorController {motorController},
     heartRateSensor {heartRateSensor},
     motionSensor {motionSensor},
     settingsController {settingsController},
-    nimbleController(*this, bleController, dateTimeController, notificationManager, batteryController, spiNorFlash, heartRateController) {
+    heartRateController{heartRateController},
+    nimbleController(*this, bleController, dateTimeController, notificationManager, batteryController, spiNorFlash, heartRateController),
+    motionController{motionController},
+    displayApp{displayApp},
+    heartRateApp(heartRateApp) {
   systemTasksMsgQueue = xQueueCreate(10, 1);
 }
 
@@ -96,9 +107,11 @@ void SystemTask::Work() {
 
   twiMaster.Init();
   touchPanel.Init();
+  dateTimeController.Register(this);
   batteryController.Init();
   motorController.Init();
   motionSensor.SoftReset();
+  timerController.Register(this);
   timerController.Init();
 
   // Reset the TWI device because the motion sensor chip most probably crashed it...
@@ -108,28 +121,14 @@ void SystemTask::Work() {
   motionSensor.Init();
   settingsController.Init();
 
-  displayApp = std::make_unique<Pinetime::Applications::DisplayApp>(lcd,
-                                                                    lvgl,
-                                                                    touchPanel,
-                                                                    batteryController,
-                                                                    bleController,
-                                                                    dateTimeController,
-                                                                    watchdogView,
-                                                                    *this,
-                                                                    notificationManager,
-                                                                    heartRateController,
-                                                                    settingsController,
-                                                                    motorController,
-                                                                    motionController,
-                                                                    timerController);
-  displayApp->Start();
-
-  displayApp->PushMessage(Pinetime::Applications::Display::Messages::UpdateBatteryLevel);
+  displayApp.Register(this);
+  displayApp.Start();
+
+  displayApp.PushMessage(Pinetime::Applications::Display::Messages::UpdateBatteryLevel);
 
   heartRateSensor.Init();
   heartRateSensor.Disable();
-  heartRateApp = std::make_unique<Pinetime::Applications::HeartRateTask>(heartRateSensor, heartRateController);
-  heartRateApp->Start();
+  heartRateApp.Start();
 
   nrf_gpio_cfg_sense_input(pinButton, (nrf_gpio_pin_pull_t) GPIO_PIN_CNF_PULL_Pulldown, (nrf_gpio_pin_sense_t) GPIO_PIN_CNF_SENSE_High);
   nrf_gpio_cfg_output(15);
@@ -208,9 +207,9 @@ void SystemTask::Work() {
           spiNorFlash.Wakeup();
           lcd.Wakeup();
 
-          displayApp->PushMessage(Pinetime::Applications::Display::Messages::GoToRunning);
-          displayApp->PushMessage(Pinetime::Applications::Display::Messages::UpdateBatteryLevel);
-          heartRateApp->PushMessage(Pinetime::Applications::HeartRateTask::Messages::WakeUp);
+          displayApp.PushMessage(Pinetime::Applications::Display::Messages::GoToRunning);
+          displayApp.PushMessage(Pinetime::Applications::Display::Messages::UpdateBatteryLevel);
+          heartRateApp.PushMessage(Pinetime::Applications::HeartRateTask::Messages::WakeUp);
 
           isSleeping = false;
           isWakingUp = false;
@@ -230,26 +229,26 @@ void SystemTask::Work() {
           isGoingToSleep = true;
           NRF_LOG_INFO("[systemtask] Going to sleep");
           xTimerStop(idleTimer, 0);
-          displayApp->PushMessage(Pinetime::Applications::Display::Messages::GoToSleep);
-          heartRateApp->PushMessage(Pinetime::Applications::HeartRateTask::Messages::GoToSleep);
+          displayApp.PushMessage(Pinetime::Applications::Display::Messages::GoToSleep);
+          heartRateApp.PushMessage(Pinetime::Applications::HeartRateTask::Messages::GoToSleep);
           break;
         case Messages::OnNewTime:
           ReloadIdleTimer();
-          displayApp->PushMessage(Pinetime::Applications::Display::Messages::UpdateDateTime);
+          displayApp.PushMessage(Pinetime::Applications::Display::Messages::UpdateDateTime);
           break;
         case Messages::OnNewNotification:
           if (isSleeping && !isWakingUp) {
             GoToRunning();
           }
           motorController.SetDuration(35);
-          displayApp->PushMessage(Pinetime::Applications::Display::Messages::NewNotification);
+          displayApp.PushMessage(Pinetime::Applications::Display::Messages::NewNotification);
           break;
         case Messages::OnTimerDone:
           if (isSleeping && !isWakingUp) {
             GoToRunning();
           }
           motorController.SetDuration(35);
-          displayApp->PushMessage(Pinetime::Applications::Display::Messages::TimerDone);
+          displayApp.PushMessage(Pinetime::Applications::Display::Messages::TimerDone);
           break;
         case Messages::BleConnected:
           ReloadIdleTimer();
@@ -260,7 +259,7 @@ void SystemTask::Work() {
           doNotGoToSleep = true;
           if (isSleeping && !isWakingUp)
             GoToRunning();
-          displayApp->PushMessage(Pinetime::Applications::Display::Messages::BleFirmwareUpdateStarted);
+          displayApp.PushMessage(Pinetime::Applications::Display::Messages::BleFirmwareUpdateStarted);
           break;
         case Messages::BleFirmwareUpdateFinished:
           doNotGoToSleep = false;
@@ -359,7 +358,7 @@ void SystemTask::OnButtonPushed() {
   if (!isSleeping) {
     NRF_LOG_INFO("[systemtask] Button pushed");
     PushMessage(Messages::OnButtonEvent);
-    displayApp->PushMessage(Pinetime::Applications::Display::Messages::ButtonPushed);
+    displayApp.PushMessage(Pinetime::Applications::Display::Messages::ButtonPushed);
   } else {
     if (!isWakingUp) {
       NRF_LOG_INFO("[systemtask] Button pushed, waking up");
@@ -380,7 +379,7 @@ void SystemTask::OnTouchEvent() {
     return;
   if (!isSleeping) {
     PushMessage(Messages::OnTouchEvent);
-    displayApp->PushMessage(Pinetime::Applications::Display::Messages::TouchEvent);
+    displayApp.PushMessage(Pinetime::Applications::Display::Messages::TouchEvent);
   } else if (!isWakingUp) {
     if (settingsController.getWakeUpMode() == Pinetime::Controllers::Settings::WakeUpMode::None or
         settingsController.getWakeUpMode() == Pinetime::Controllers::Settings::WakeUpMode::RaiseWrist)
@@ -389,7 +388,7 @@ void SystemTask::OnTouchEvent() {
   }
 }
 
-void SystemTask::PushMessage(SystemTask::Messages msg) {
+void SystemTask::PushMessage(System::Messages msg) {
   if (msg == Messages::GoToSleep) {
     isGoingToSleep = true;
   }
-- 
cgit v1.2.3-70-g09d2


From b1925ff28638dd4b8400c4d0c49d796d8990b1af Mon Sep 17 00:00:00 2001
From: Jean-François Milants <jf@codingfield.com>
Date: Thu, 10 Jun 2021 21:20:27 +0200
Subject: Minor improvements: use std::make_unique when creating unique_ptr,
 check the code is running from an IRQ before calling xQueueSendFromISR or
 xQueueSend)

---
 src/displayapp/DisplayApp.cpp                | 21 +++++++++++++++------
 src/displayapp/screens/SystemInfo.cpp        | 10 +++++-----
 src/displayapp/screens/settings/Settings.cpp |  4 ++--
 src/displayapp/screens/settings/Settings.h   |  1 -
 src/drivers/SpiMaster.cpp                    |  8 ++++----
 src/systemtask/SystemTask.cpp                | 24 ++++++++++++++++++------
 6 files changed, 44 insertions(+), 24 deletions(-)

(limited to 'src/systemtask/SystemTask.cpp')

diff --git a/src/displayapp/DisplayApp.cpp b/src/displayapp/DisplayApp.cpp
index 99758c92..3bfaf2a2 100644
--- a/src/displayapp/DisplayApp.cpp
+++ b/src/displayapp/DisplayApp.cpp
@@ -45,6 +45,12 @@
 using namespace Pinetime::Applications;
 using namespace Pinetime::Applications::Display;
 
+namespace {
+  static inline bool in_isr(void) {
+    return (SCB->ICSR & SCB_ICSR_VECTACTIVE_Msk) != 0;
+  }
+}
+
 DisplayApp::DisplayApp(Drivers::St7789& lcd,
                        Components::LittleVgl& lvgl,
                        Drivers::Cst816S& touchPanel,
@@ -364,12 +370,15 @@ void DisplayApp::IdleState() {
 }
 
 void DisplayApp::PushMessage(Messages msg) {
-  BaseType_t xHigherPriorityTaskWoken;
-  xHigherPriorityTaskWoken = pdFALSE;
-  xQueueSendFromISR(msgQueue, &msg, &xHigherPriorityTaskWoken);
-  if (xHigherPriorityTaskWoken) {
-    /* Actual macro used here is port specific. */
-    // TODO : should I do something here?
+  if(in_isr()) {
+    BaseType_t xHigherPriorityTaskWoken;
+    xHigherPriorityTaskWoken = pdFALSE;
+    xQueueSendFromISR(msgQueue, &msg, &xHigherPriorityTaskWoken);
+    if (xHigherPriorityTaskWoken) {
+      portYIELD_FROM_ISR(xHigherPriorityTaskWoken);
+    }
+  } else {
+    xQueueSend(msgQueue, &msg, portMAX_DELAY);
   }
 }
 
diff --git a/src/displayapp/screens/SystemInfo.cpp b/src/displayapp/screens/SystemInfo.cpp
index f61d2ff1..a7387dac 100644
--- a/src/displayapp/screens/SystemInfo.cpp
+++ b/src/displayapp/screens/SystemInfo.cpp
@@ -81,7 +81,7 @@ std::unique_ptr<Screen> SystemInfo::CreateScreen1() {
                         __TIME__);
   lv_label_set_align(label, LV_LABEL_ALIGN_CENTER);
   lv_obj_align(label, lv_scr_act(), LV_ALIGN_CENTER, 0, 0);
-  return std::unique_ptr<Screen>(new Screens::Label(0, 5, app, label));
+  return std::make_unique<Screens::Label>(0, 5, app, label);
 }
 
 std::unique_ptr<Screen> SystemInfo::CreateScreen2() {
@@ -161,7 +161,7 @@ std::unique_ptr<Screen> SystemInfo::CreateScreen2() {
                         brightnessController.ToString(),
                         resetReason);
   lv_obj_align(label, lv_scr_act(), LV_ALIGN_CENTER, 0, 0);
-  return std::unique_ptr<Screen>(new Screens::Label(1, 4, app, label));
+  return std::make_unique<Screens::Label>(1, 4, app, label);
 }
 
 std::unique_ptr<Screen> SystemInfo::CreateScreen3() {
@@ -195,7 +195,7 @@ std::unique_ptr<Screen> SystemInfo::CreateScreen3() {
                         (int) mon.free_biggest_size,
                         0);
   lv_obj_align(label, lv_scr_act(), LV_ALIGN_CENTER, 0, 0);
-  return std::unique_ptr<Screen>(new Screens::Label(2, 5, app, label));
+  return std::make_unique<Screens::Label>(2, 5, app, label);
 }
 
 bool sortById(const TaskStatus_t& lhs, const TaskStatus_t& rhs) {
@@ -229,7 +229,7 @@ std::unique_ptr<Screen> SystemInfo::CreateScreen4() {
       lv_table_set_cell_value(infoTask, i + 1, 2, std::to_string(tasksStatus[i].usStackHighWaterMark).c_str());
     }
   }
-  return std::unique_ptr<Screen>(new Screens::Label(3, 5, app, infoTask));
+  return std::make_unique<Screens::Label>(3, 5, app, infoTask);
 }
 
 std::unique_ptr<Screen> SystemInfo::CreateScreen5() {
@@ -245,5 +245,5 @@ std::unique_ptr<Screen> SystemInfo::CreateScreen5() {
                            "#FFFF00 JF002/InfiniTime#");
   lv_label_set_align(label, LV_LABEL_ALIGN_CENTER);
   lv_obj_align(label, lv_scr_act(), LV_ALIGN_CENTER, 0, 0);
-  return std::unique_ptr<Screen>(new Screens::Label(4, 5, app, label));
+  return std::make_unique<Screens::Label>(4, 5, app, label);
 }
diff --git a/src/displayapp/screens/settings/Settings.cpp b/src/displayapp/screens/settings/Settings.cpp
index 2c72c832..e63a3584 100644
--- a/src/displayapp/screens/settings/Settings.cpp
+++ b/src/displayapp/screens/settings/Settings.cpp
@@ -46,7 +46,7 @@ std::unique_ptr<Screen> Settings::CreateScreen1() {
     {Symbols::clock, "Watch face", Apps::SettingWatchFace},
   }};
 
-  return std::unique_ptr<Screen>(new Screens::List(0, 2, app, settingsController, applications));
+  return std::make_unique<Screens::List>(0, 2, app, settingsController, applications);
 }
 
 std::unique_ptr<Screen> Settings::CreateScreen2() {
@@ -58,5 +58,5 @@ std::unique_ptr<Screen> Settings::CreateScreen2() {
     {Symbols::list, "About", Apps::SysInfo},
   }};
 
-  return std::unique_ptr<Screen>(new Screens::List(1, 2, app, settingsController, applications));
+  return std::make_unique<Screens::List>(1, 2, app, settingsController, applications);
 }
diff --git a/src/displayapp/screens/settings/Settings.h b/src/displayapp/screens/settings/Settings.h
index 7e332dfe..711a6be6 100644
--- a/src/displayapp/screens/settings/Settings.h
+++ b/src/displayapp/screens/settings/Settings.h
@@ -16,7 +16,6 @@ namespace Pinetime {
 
         bool Refresh() override;
 
-        void OnButtonEvent(lv_obj_t* object, lv_event_t event);
         bool OnTouchEvent(Pinetime::Applications::TouchEvents event) override;
 
       private:
diff --git a/src/drivers/SpiMaster.cpp b/src/drivers/SpiMaster.cpp
index 34fcc08a..e2be5027 100644
--- a/src/drivers/SpiMaster.cpp
+++ b/src/drivers/SpiMaster.cpp
@@ -132,17 +132,17 @@ void SpiMaster::OnEndEvent() {
 
     spiBaseAddress->TASKS_START = 1;
   } else {
+    BaseType_t xHigherPriorityTaskWoken = pdFALSE;
     if (taskToNotify != nullptr) {
-      BaseType_t xHigherPriorityTaskWoken = pdFALSE;
       vTaskNotifyGiveFromISR(taskToNotify, &xHigherPriorityTaskWoken);
       portYIELD_FROM_ISR(xHigherPriorityTaskWoken);
     }
 
     nrf_gpio_pin_set(this->pinCsn);
     currentBufferAddr = 0;
-    BaseType_t xHigherPriorityTaskWoken = pdFALSE;
-    xSemaphoreGiveFromISR(mutex, &xHigherPriorityTaskWoken);
-    portYIELD_FROM_ISR(xHigherPriorityTaskWoken);
+    BaseType_t xHigherPriorityTaskWoken2 = pdFALSE;
+    xSemaphoreGiveFromISR(mutex, &xHigherPriorityTaskWoken2);
+    portYIELD_FROM_ISR(xHigherPriorityTaskWoken | xHigherPriorityTaskWoken2);
   }
 }
 
diff --git a/src/systemtask/SystemTask.cpp b/src/systemtask/SystemTask.cpp
index be484bb4..4799624a 100644
--- a/src/systemtask/SystemTask.cpp
+++ b/src/systemtask/SystemTask.cpp
@@ -27,6 +27,12 @@
 
 using namespace Pinetime::System;
 
+namespace {
+  static inline bool in_isr(void) {
+    return (SCB->ICSR & SCB_ICSR_VECTACTIVE_Msk) != 0;
+  }
+}
+
 void IdleTimerCallback(TimerHandle_t xTimer) {
 
   NRF_LOG_INFO("IdleTimerCallback");
@@ -392,12 +398,18 @@ void SystemTask::PushMessage(System::Messages msg) {
   if (msg == Messages::GoToSleep) {
     isGoingToSleep = true;
   }
-  BaseType_t xHigherPriorityTaskWoken;
-  xHigherPriorityTaskWoken = pdFALSE;
-  xQueueSendFromISR(systemTasksMsgQueue, &msg, &xHigherPriorityTaskWoken);
-  if (xHigherPriorityTaskWoken) {
-    /* Actual macro used here is port specific. */
-    // TODO: should I do something here?
+
+  if(in_isr()) {
+    BaseType_t xHigherPriorityTaskWoken;
+    xHigherPriorityTaskWoken = pdFALSE;
+    xQueueSendFromISR(systemTasksMsgQueue, &msg, &xHigherPriorityTaskWoken);
+    if (xHigherPriorityTaskWoken) {
+      /* Actual macro used here is port specific. */
+      portYIELD_FROM_ISR(xHigherPriorityTaskWoken);
+
+    }
+  } else {
+    xQueueSend(systemTasksMsgQueue, &msg, portMAX_DELAY);
   }
 }
 
-- 
cgit v1.2.3-70-g09d2


From 6d524ebea2c97e309633d5e01c3a1e37c182f27d Mon Sep 17 00:00:00 2001
From: Jean-François Milants <jf@codingfield.com>
Date: Sat, 12 Jun 2021 10:58:28 +0200
Subject: Move most of the code from the constructor of the objects statically
 initialized in main() into Start()/Init() functions to avoid Static
 Initialization Order Fiasco
 (https://en.cppreference.com/w/cpp/language/siof). See
 https://github.com/JF002/InfiniTime/pull/415#issuecomment-859004238.

---
 src/displayapp/DisplayApp.cpp         | 6 ++++--
 src/displayapp/DisplayAppRecovery.cpp | 3 ++-
 src/displayapp/LittleVgl.cpp          | 4 ++++
 src/displayapp/LittleVgl.h            | 2 ++
 src/drivers/SpiMaster.cpp             | 7 +++++--
 src/drivers/SpiMaster.h               | 2 +-
 src/drivers/TwiMaster.cpp             | 4 +++-
 src/drivers/TwiMaster.h               | 2 +-
 src/heartratetask/HeartRateTask.cpp   | 5 +++--
 src/main.cpp                          | 2 ++
 src/systemtask/SystemTask.cpp         | 3 ++-
 11 files changed, 29 insertions(+), 11 deletions(-)

(limited to 'src/systemtask/SystemTask.cpp')

diff --git a/src/displayapp/DisplayApp.cpp b/src/displayapp/DisplayApp.cpp
index 3bfaf2a2..05f171be 100644
--- a/src/displayapp/DisplayApp.cpp
+++ b/src/displayapp/DisplayApp.cpp
@@ -77,12 +77,14 @@ DisplayApp::DisplayApp(Drivers::St7789& lcd,
     motorController {motorController},
     motionController {motionController},
     timerController {timerController} {
+}
+
+void DisplayApp::Start() {
   msgQueue = xQueueCreate(queueSize, itemSize);
+
   // Start clock when smartwatch boots
   LoadApp(Apps::Clock, DisplayApp::FullRefreshDirections::None);
-}
 
-void DisplayApp::Start() {
   if (pdPASS != xTaskCreate(DisplayApp::Process, "displayapp", 800, this, 0, &taskHandle)) {
     APP_ERROR_HANDLER(NRF_ERROR_NO_MEM);
   }
diff --git a/src/displayapp/DisplayAppRecovery.cpp b/src/displayapp/DisplayAppRecovery.cpp
index b73d0a85..fd517b11 100644
--- a/src/displayapp/DisplayAppRecovery.cpp
+++ b/src/displayapp/DisplayAppRecovery.cpp
@@ -21,10 +21,11 @@ DisplayApp::DisplayApp(Drivers::St7789& lcd,
                        Pinetime::Controllers::MotionController& motionController,
                        Pinetime::Controllers::TimerController& timerController)
   : lcd {lcd}, bleController {bleController} {
-  msgQueue = xQueueCreate(queueSize, itemSize);
+
 }
 
 void DisplayApp::Start() {
+  msgQueue = xQueueCreate(queueSize, itemSize);
   if (pdPASS != xTaskCreate(DisplayApp::Process, "displayapp", 512, this, 0, &taskHandle))
     APP_ERROR_HANDLER(NRF_ERROR_NO_MEM);
 }
diff --git a/src/displayapp/LittleVgl.cpp b/src/displayapp/LittleVgl.cpp
index 36df51b4..c069afa2 100644
--- a/src/displayapp/LittleVgl.cpp
+++ b/src/displayapp/LittleVgl.cpp
@@ -23,6 +23,10 @@ bool touchpad_read(lv_indev_drv_t* indev_drv, lv_indev_data_t* data) {
 
 LittleVgl::LittleVgl(Pinetime::Drivers::St7789& lcd, Pinetime::Drivers::Cst816S& touchPanel)
   : lcd {lcd}, touchPanel {touchPanel}, previousClick {0, 0} {
+
+}
+
+void LittleVgl::Init() {
   lv_init();
   InitTheme();
   InitDisplay();
diff --git a/src/displayapp/LittleVgl.h b/src/displayapp/LittleVgl.h
index 7f7b76e0..41f934a7 100644
--- a/src/displayapp/LittleVgl.h
+++ b/src/displayapp/LittleVgl.h
@@ -19,6 +19,8 @@ namespace Pinetime {
       LittleVgl(LittleVgl&&) = delete;
       LittleVgl& operator=(LittleVgl&&) = delete;
 
+      void Init();
+
       void FlushDisplay(const lv_area_t* area, lv_color_t* color_p);
       bool GetTouchPadInfo(lv_indev_data_t* ptr);
       void SetFullRefresh(FullRefreshDirections direction);
diff --git a/src/drivers/SpiMaster.cpp b/src/drivers/SpiMaster.cpp
index e2be5027..0d5bb83c 100644
--- a/src/drivers/SpiMaster.cpp
+++ b/src/drivers/SpiMaster.cpp
@@ -7,11 +7,14 @@
 using namespace Pinetime::Drivers;
 
 SpiMaster::SpiMaster(const SpiMaster::SpiModule spi, const SpiMaster::Parameters& params) : spi {spi}, params {params} {
-  mutex = xSemaphoreCreateBinary();
-  ASSERT(mutex != NULL);
 }
 
 bool SpiMaster::Init() {
+  if(mutex == nullptr) {
+    mutex = xSemaphoreCreateBinary();
+    ASSERT(mutex != nullptr);
+  }
+
   /* Configure GPIO pins used for pselsck, pselmosi, pselmiso and pselss for SPI0 */
   nrf_gpio_pin_set(params.pinSCK);
   nrf_gpio_cfg_output(params.pinSCK);
diff --git a/src/drivers/SpiMaster.h b/src/drivers/SpiMaster.h
index 5045369a..5ea624f2 100644
--- a/src/drivers/SpiMaster.h
+++ b/src/drivers/SpiMaster.h
@@ -59,7 +59,7 @@ namespace Pinetime {
       volatile uint32_t currentBufferAddr = 0;
       volatile size_t currentBufferSize = 0;
       volatile TaskHandle_t taskToNotify;
-      SemaphoreHandle_t mutex;
+      SemaphoreHandle_t mutex = nullptr;
     };
   }
 }
diff --git a/src/drivers/TwiMaster.cpp b/src/drivers/TwiMaster.cpp
index 7b6582dd..fc9edf81 100644
--- a/src/drivers/TwiMaster.cpp
+++ b/src/drivers/TwiMaster.cpp
@@ -9,10 +9,12 @@ using namespace Pinetime::Drivers;
 // TODO use DMA/IRQ
 
 TwiMaster::TwiMaster(const Modules module, const Parameters& params) : module {module}, params {params} {
-  mutex = xSemaphoreCreateBinary();
 }
 
 void TwiMaster::Init() {
+  if(mutex == nullptr)
+    mutex = xSemaphoreCreateBinary();
+  
   NRF_GPIO->PIN_CNF[params.pinScl] =
     ((uint32_t) GPIO_PIN_CNF_DIR_Input << GPIO_PIN_CNF_DIR_Pos) | ((uint32_t) GPIO_PIN_CNF_INPUT_Connect << GPIO_PIN_CNF_INPUT_Pos) |
     ((uint32_t) GPIO_PIN_CNF_PULL_Pullup << GPIO_PIN_CNF_PULL_Pos) | ((uint32_t) GPIO_PIN_CNF_DRIVE_S0D1 << GPIO_PIN_CNF_DRIVE_Pos) |
diff --git a/src/drivers/TwiMaster.h b/src/drivers/TwiMaster.h
index 1c0648a2..6175b99b 100644
--- a/src/drivers/TwiMaster.h
+++ b/src/drivers/TwiMaster.h
@@ -31,7 +31,7 @@ namespace Pinetime {
       ErrorCodes Write(uint8_t deviceAddress, const uint8_t* data, size_t size, bool stop);
       void FixHwFreezed();
       NRF_TWIM_Type* twiBaseAddress;
-      SemaphoreHandle_t mutex;
+      SemaphoreHandle_t mutex = nullptr;
       const Modules module;
       const Parameters params;
       static constexpr uint8_t maxDataSize {16};
diff --git a/src/heartratetask/HeartRateTask.cpp b/src/heartratetask/HeartRateTask.cpp
index 1c21db71..fddc05d7 100644
--- a/src/heartratetask/HeartRateTask.cpp
+++ b/src/heartratetask/HeartRateTask.cpp
@@ -7,11 +7,12 @@ using namespace Pinetime::Applications;
 
 HeartRateTask::HeartRateTask(Drivers::Hrs3300& heartRateSensor, Controllers::HeartRateController& controller)
   : heartRateSensor {heartRateSensor}, controller {controller}, ppg{} {
-  messageQueue = xQueueCreate(10, 1);
-  controller.SetHeartRateTask(this);
 }
 
 void HeartRateTask::Start() {
+  messageQueue = xQueueCreate(10, 1);
+  controller.SetHeartRateTask(this);
+
   if (pdPASS != xTaskCreate(HeartRateTask::Process, "Heartrate", 500, this, 0, &taskHandle))
     APP_ERROR_HANDLER(NRF_ERROR_NO_MEM);
 }
diff --git a/src/main.cpp b/src/main.cpp
index 52ec9580..4c2c5de8 100644
--- a/src/main.cpp
+++ b/src/main.cpp
@@ -306,6 +306,8 @@ int main(void) {
   debounceTimer = xTimerCreate("debounceTimer", 200, pdFALSE, (void*) 0, DebounceTimerCallback);
   debounceChargeTimer = xTimerCreate("debounceTimerCharge", 200, pdFALSE, (void*) 0, DebounceTimerChargeCallback);
 
+  lvgl.Init();
+
   systemTask.Start();
   nimble_port_init();
 
diff --git a/src/systemtask/SystemTask.cpp b/src/systemtask/SystemTask.cpp
index 4799624a..38e9793c 100644
--- a/src/systemtask/SystemTask.cpp
+++ b/src/systemtask/SystemTask.cpp
@@ -81,10 +81,11 @@ SystemTask::SystemTask(Drivers::SpiMaster& spi,
     motionController{motionController},
     displayApp{displayApp},
     heartRateApp(heartRateApp) {
-  systemTasksMsgQueue = xQueueCreate(10, 1);
+
 }
 
 void SystemTask::Start() {
+  systemTasksMsgQueue = xQueueCreate(10, 1);
   if (pdPASS != xTaskCreate(SystemTask::Process, "MAIN", 350, this, 0, &taskHandle))
     APP_ERROR_HANDLER(NRF_ERROR_NO_MEM);
 }
-- 
cgit v1.2.3-70-g09d2


From c6dca25b9fa30af989baf748f6c32b38eaa95bac Mon Sep 17 00:00:00 2001
From: JF002 <JF002@users.noreply.github.com>
Date: Sat, 19 Jun 2021 20:27:59 +0200
Subject: Add support for BMA425 acceleration sensor. (#440)

* Add support for BMA425 acceleration sensor.
---
 src/components/motion/MotionController.cpp |   7 +
 src/components/motion/MotionController.h   |  14 +
 src/displayapp/DisplayApp.cpp              |   2 +-
 src/displayapp/screens/SystemInfo.cpp      |  27 +-
 src/displayapp/screens/SystemInfo.h        |   4 +-
 src/drivers/Bma421.cpp                     |   9 +
 src/drivers/Bma421.h                       |   7 +
 src/drivers/Bma421_C/bma423.c              | 560 +++++++++++++++++++++++++++--
 src/drivers/Bma421_C/bma423.h              |   1 +
 src/systemtask/SystemTask.cpp              |   1 +
 10 files changed, 603 insertions(+), 29 deletions(-)

(limited to 'src/systemtask/SystemTask.cpp')

diff --git a/src/components/motion/MotionController.cpp b/src/components/motion/MotionController.cpp
index e9ee314b..b0dbada4 100644
--- a/src/components/motion/MotionController.cpp
+++ b/src/components/motion/MotionController.cpp
@@ -34,3 +34,10 @@ bool MotionController::ShouldWakeUp(bool isSleeping) {
 void MotionController::IsSensorOk(bool isOk) {
   isSensorOk = isOk;
 }
+void MotionController::Init(Pinetime::Drivers::Bma421::DeviceTypes types) {
+  switch(types){
+    case Drivers::Bma421::DeviceTypes::BMA421: this->deviceType = DeviceTypes::BMA421; break;
+    case Drivers::Bma421::DeviceTypes::BMA425: this->deviceType = DeviceTypes::BMA425; break;
+    default: this->deviceType = DeviceTypes::Unknown; break;
+  }
+}
diff --git a/src/components/motion/MotionController.h b/src/components/motion/MotionController.h
index 3a238262..ff715093 100644
--- a/src/components/motion/MotionController.h
+++ b/src/components/motion/MotionController.h
@@ -1,11 +1,18 @@
 #pragma once
 
 #include <cstdint>
+#include <drivers/Bma421.h>
 
 namespace Pinetime {
   namespace Controllers {
     class MotionController {
     public:
+      enum class DeviceTypes{
+        Unknown,
+        BMA421,
+        BMA425,
+      };
+
       void Update(int16_t x, int16_t y, int16_t z, uint32_t nbSteps);
 
       int16_t X() const {
@@ -27,6 +34,12 @@ namespace Pinetime {
         return isSensorOk;
       }
 
+      DeviceTypes DeviceType() const {
+        return deviceType;
+      }
+
+      void Init(Pinetime::Drivers::Bma421::DeviceTypes types);
+
     private:
       uint32_t nbSteps;
       int16_t x;
@@ -34,6 +47,7 @@ namespace Pinetime {
       int16_t z;
       int16_t lastYForWakeUp = 0;
       bool isSensorOk = false;
+      DeviceTypes deviceType = DeviceTypes::Unknown;
     };
   }
 }
\ No newline at end of file
diff --git a/src/displayapp/DisplayApp.cpp b/src/displayapp/DisplayApp.cpp
index ab73969d..de93428c 100644
--- a/src/displayapp/DisplayApp.cpp
+++ b/src/displayapp/DisplayApp.cpp
@@ -329,7 +329,7 @@ void DisplayApp::LoadApp(Apps app, DisplayApp::FullRefreshDirections direction)
       break;
     case Apps::SysInfo:
       currentScreen =
-        std::make_unique<Screens::SystemInfo>(this, dateTimeController, batteryController, brightnessController, bleController, watchdog);
+        std::make_unique<Screens::SystemInfo>(this, dateTimeController, batteryController, brightnessController, bleController, watchdog, motionController);
       ReturnApp(Apps::Settings, FullRefreshDirections::Down, TouchEvents::SwipeDown);
       break;
     case Apps::FlashLight:
diff --git a/src/displayapp/screens/SystemInfo.cpp b/src/displayapp/screens/SystemInfo.cpp
index 9ff28288..0b16d633 100644
--- a/src/displayapp/screens/SystemInfo.cpp
+++ b/src/displayapp/screens/SystemInfo.cpp
@@ -7,22 +7,37 @@
 #include "components/ble/BleController.h"
 #include "components/brightness/BrightnessController.h"
 #include "components/datetime/DateTimeController.h"
+#include "components/motion/MotionController.h"
 #include "drivers/Watchdog.h"
 
 using namespace Pinetime::Applications::Screens;
 
+namespace {
+  const char* ToString(const Pinetime::Controllers::MotionController::DeviceTypes deviceType) {
+    switch (deviceType) {
+      case Pinetime::Controllers::MotionController::DeviceTypes::BMA421:
+        return "BMA421";
+      case Pinetime::Controllers::MotionController::DeviceTypes::BMA425:
+        return "BMA425";
+    }
+    return "???";
+  }
+}
+
 SystemInfo::SystemInfo(Pinetime::Applications::DisplayApp* app,
                        Pinetime::Controllers::DateTime& dateTimeController,
                        Pinetime::Controllers::Battery& batteryController,
                        Pinetime::Controllers::BrightnessController& brightnessController,
                        Pinetime::Controllers::Ble& bleController,
-                       Pinetime::Drivers::WatchdogView& watchdog)
+                       Pinetime::Drivers::WatchdogView& watchdog,
+                       Pinetime::Controllers::MotionController& motionController)
   : Screen(app),
     dateTimeController {dateTimeController},
     batteryController {batteryController},
     brightnessController {brightnessController},
     bleController {bleController},
     watchdog {watchdog},
+    motionController{motionController},
     screens {app,
              0,
              {[this]() -> std::unique_ptr<Screen> {
@@ -132,9 +147,7 @@ std::unique_ptr<Screen> SystemInfo::CreateScreen2() {
   // hack to not use the flot functions from printf
   uint8_t batteryVoltageBytes[2];
   batteryVoltageBytes[1] = static_cast<uint8_t>(batteryVoltage); // truncate whole numbers
-  batteryVoltageBytes[0] =
-    static_cast<uint8_t>((batteryVoltage - batteryVoltageBytes[1]) * 100); // remove whole part of flt and shift 2 places over
-  //
+  batteryVoltageBytes[0] = static_cast<uint8_t>((batteryVoltage - batteryVoltageBytes[1]) * 100); // remove whole part of flt and shift 2 places over
 
   lv_obj_t* label = lv_label_create(lv_scr_act(), nullptr);
   lv_label_set_recolor(label, true);
@@ -144,7 +157,8 @@ std::unique_ptr<Screen> SystemInfo::CreateScreen2() {
                         "#444444 Uptime#\n %02lud %02lu:%02lu:%02lu\n"
                         "#444444 Battery# %d%%/%1i.%02iv\n"
                         "#444444 Backlight# %s\n"
-                        "#444444 Last reset# %s\n",
+                        "#444444 Last reset# %s\n"
+                        "#444444 Accel.# %s\n",
                         dateTimeController.Day(),
                         static_cast<uint8_t>(dateTimeController.Month()),
                         dateTimeController.Year(),
@@ -159,7 +173,8 @@ std::unique_ptr<Screen> SystemInfo::CreateScreen2() {
                         batteryVoltageBytes[1],
                         batteryVoltageBytes[0],
                         brightnessController.ToString(),
-                        resetReason);
+                        resetReason,
+                        ToString(motionController.DeviceType()));
   lv_obj_align(label, lv_scr_act(), LV_ALIGN_CENTER, 0, 0);
   return std::make_unique<Screens::Label>(1, 5, app, label);
 }
diff --git a/src/displayapp/screens/SystemInfo.h b/src/displayapp/screens/SystemInfo.h
index c61a07a2..9d471f61 100644
--- a/src/displayapp/screens/SystemInfo.h
+++ b/src/displayapp/screens/SystemInfo.h
@@ -27,7 +27,8 @@ namespace Pinetime {
                             Pinetime::Controllers::Battery& batteryController,
                             Pinetime::Controllers::BrightnessController& brightnessController,
                             Pinetime::Controllers::Ble& bleController,
-                            Pinetime::Drivers::WatchdogView& watchdog);
+                            Pinetime::Drivers::WatchdogView& watchdog,
+                            Pinetime::Controllers::MotionController& motionController);
         ~SystemInfo() override;
         bool Refresh() override;
         bool OnButtonPushed() override;
@@ -41,6 +42,7 @@ namespace Pinetime {
         Pinetime::Controllers::BrightnessController& brightnessController;
         Pinetime::Controllers::Ble& bleController;
         Pinetime::Drivers::WatchdogView& watchdog;
+        Pinetime::Controllers::MotionController& motionController;
 
         ScreenList<5> screens;
 
diff --git a/src/drivers/Bma421.cpp b/src/drivers/Bma421.cpp
index 35b2c105..dd284000 100644
--- a/src/drivers/Bma421.cpp
+++ b/src/drivers/Bma421.cpp
@@ -42,6 +42,12 @@ void Bma421::Init() {
   if (ret != BMA4_OK)
     return;
 
+  switch(bma.chip_id) {
+    case BMA423_CHIP_ID: deviceType = DeviceTypes::BMA421; break;
+    case BMA425_CHIP_ID: deviceType = DeviceTypes::BMA425; break;
+    default: deviceType = DeviceTypes::Unknown; break;
+  }
+
   ret = bma423_write_config_file(&bma);
   if (ret != BMA4_OK)
     return;
@@ -121,3 +127,6 @@ void Bma421::SoftReset() {
     nrf_delay_ms(1);
   }
 }
+Bma421::DeviceTypes Bma421::DeviceType() const {
+  return deviceType;
+}
diff --git a/src/drivers/Bma421.h b/src/drivers/Bma421.h
index e4d925f5..ace644bd 100644
--- a/src/drivers/Bma421.h
+++ b/src/drivers/Bma421.h
@@ -6,6 +6,11 @@ namespace Pinetime {
     class TwiMaster;
     class Bma421 {
     public:
+      enum class DeviceTypes : uint8_t {
+        Unknown,
+        BMA421,
+        BMA425
+      };
       struct Values {
         uint32_t steps;
         int16_t x;
@@ -29,6 +34,7 @@ namespace Pinetime {
       void Write(uint8_t registerAddress, const uint8_t* data, size_t size);
 
       bool IsOk() const;
+      DeviceTypes DeviceType() const;
 
     private:
       void Reset();
@@ -38,6 +44,7 @@ namespace Pinetime {
       struct bma4_dev bma;
       bool isOk = false;
       bool isResetOk = false;
+      DeviceTypes deviceType = DeviceTypes::Unknown;
     };
   }
 }
\ No newline at end of file
diff --git a/src/drivers/Bma421_C/bma423.c b/src/drivers/Bma421_C/bma423.c
index 1d782705..7d6c2e0a 100644
--- a/src/drivers/Bma421_C/bma423.c
+++ b/src/drivers/Bma421_C/bma423.c
@@ -43,6 +43,521 @@
 #include "bma423.h"
 
 /**\name Feature configuration file */
+const uint8_t bma425_config_file[] = {
+  0x80, 0x2e, 0xfd, 0x00, 0x80, 0x2e, 0xff, 0x00, 0xc8, 0x2e, 0x00, 0x2e,
+  0x80, 0x2e, 0xfb, 0x00, 0x80, 0x2e, 0xdd, 0xb0, 0x80, 0x2e, 0xfe, 0x00,
+  0x80, 0x2e, 0xfc, 0x00, 0x80, 0x2e, 0x0d, 0xb1, 0x50, 0x39, 0x21, 0x2e,
+  0xb0, 0xf0, 0x10, 0x30, 0x21, 0x2e, 0x16, 0xf0, 0x80, 0x2e, 0x34, 0xb1,
+  0x65, 0x50, 0x4f, 0x52, 0x01, 0x42, 0x3b, 0x80, 0x41, 0x30, 0x01, 0x42,
+  0x3c, 0x80, 0x00, 0x2e, 0x01, 0x40, 0x01, 0x42, 0x21, 0x2e, 0xff, 0xaf,
+  0xb8, 0x2e, 0x1f, 0x7f, 0x80, 0x2e, 0x18, 0x00, 0x80, 0x2e, 0x18, 0x00,
+  0x80, 0x2e, 0x18, 0x00, 0x80, 0x2e, 0x18, 0x00, 0x80, 0x2e, 0x18, 0x00,
+  0x80, 0x2e, 0x18, 0x00, 0x80, 0x2e, 0x18, 0x00, 0x80, 0x2e, 0x18, 0x00,
+  0x80, 0x2e, 0x18, 0x00, 0x80, 0x2e, 0x18, 0x00, 0x80, 0x2e, 0x18, 0x00,
+  0x80, 0x2e, 0x18, 0x00, 0x80, 0x2e, 0x18, 0x00, 0x80, 0x2e, 0x18, 0x00,
+  0x80, 0x2e, 0x18, 0x00, 0x80, 0x2e, 0x18, 0x00, 0x80, 0x2e, 0x18, 0x00,
+  0x80, 0x2e, 0x18, 0x00, 0x80, 0x2e, 0x18, 0x00, 0x80, 0x2e, 0x18, 0x00,
+  0x80, 0x2e, 0x18, 0x00, 0xfd, 0x2d, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x04, 0x01, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00,
+  0x00, 0x00, 0x00, 0x08, 0x00, 0xf8, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08,
+  0x00, 0xf8, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x2e,
+  0x55, 0xf0, 0xc0, 0x2e, 0x21, 0x2e, 0x55, 0xf0, 0x30, 0x50, 0x00, 0x30,
+  0x51, 0x56, 0x05, 0x30, 0x05, 0x2c, 0xfb, 0x7f, 0x3e, 0xbe, 0xd2, 0xba,
+  0xb2, 0xb9, 0x6c, 0x0b, 0x53, 0x0e, 0xf9, 0x2f, 0x53, 0x1a, 0x01, 0x2f,
+  0x4d, 0x0e, 0xf5, 0x2f, 0xd2, 0x7f, 0x04, 0x30, 0x1f, 0x2c, 0xe1, 0x7f,
+  0xc5, 0x01, 0xa3, 0x03, 0x72, 0x0e, 0x03, 0x2f, 0x72, 0x1a, 0x0f, 0x2f,
+  0x79, 0x0f, 0x0d, 0x2f, 0xe1, 0x6f, 0x4f, 0x04, 0x5f, 0xb9, 0xb1, 0xbf,
+  0xfa, 0x0b, 0xd2, 0x6f, 0x96, 0x06, 0xb1, 0x25, 0x51, 0xbf, 0xeb, 0x7f,
+  0x06, 0x00, 0xb2, 0x25, 0x27, 0x03, 0xdb, 0x7f, 0xcf, 0xbf, 0x3e, 0xbf,
+  0x01, 0xb8, 0xd2, 0xba, 0x41, 0xba, 0xb2, 0xb9, 0x07, 0x0a, 0x6e, 0x0b,
+  0xc0, 0x90, 0xdf, 0x2f, 0x40, 0x91, 0xdd, 0x2f, 0xfb, 0x6f, 0xd0, 0x5f,
+  0xb8, 0x2e, 0x00, 0x31, 0xc0, 0x2e, 0x21, 0x2e, 0xba, 0xf0, 0xc8, 0x2e,
+  0xc8, 0x2e, 0xc8, 0x2e, 0xc8, 0x2e, 0xc8, 0x2e, 0xaa, 0x00, 0x05, 0x00,
+  0xaa, 0x00, 0x05, 0x00, 0x2d, 0x01, 0xd4, 0x7b, 0x3b, 0x01, 0xdb, 0x7a,
+  0x04, 0x00, 0x3f, 0x7b, 0xcd, 0x6c, 0xc3, 0x04, 0x85, 0x09, 0xc3, 0x04,
+  0xec, 0xe6, 0x0c, 0x46, 0x01, 0x00, 0x27, 0x00, 0x19, 0x00, 0x96, 0x00,
+  0xa0, 0x00, 0x01, 0x00, 0x0c, 0x00, 0xf0, 0x3c, 0x00, 0x01, 0x01, 0x00,
+  0x03, 0x00, 0x01, 0x00, 0x0e, 0x00, 0x00, 0x00, 0x06, 0x00, 0x06, 0x00,
+  0x00, 0x00, 0x47, 0x28, 0x88, 0x00, 0x54, 0x00, 0x51, 0x00, 0x97, 0x00,
+  0xa0, 0x00, 0x80, 0x00, 0x00, 0x40, 0xff, 0x7f, 0x00, 0x80, 0xaf, 0x00,
+  0xff, 0x00, 0xff, 0xb7, 0x00, 0x02, 0x00, 0xb0, 0x05, 0x80, 0xb1, 0xf0,
+  0x5e, 0xf0, 0xc0, 0x00, 0x59, 0xf0, 0x39, 0xf0, 0x57, 0x00, 0x89, 0xf0,
+  0x54, 0x00, 0x00, 0x20, 0x82, 0x00, 0x59, 0x00, 0x5d, 0x00, 0x81, 0x00,
+  0xff, 0xfb, 0x52, 0xf0, 0x56, 0xf0, 0x33, 0x09, 0x33, 0x07, 0x00, 0x08,
+  0x90, 0x01, 0x00, 0xf8, 0x00, 0x01, 0x02, 0x01, 0x60, 0x00, 0x6a, 0x00,
+  0x4c, 0x04, 0xa0, 0x00, 0xe8, 0x03, 0x81, 0x00, 0x82, 0x00, 0xeb, 0x07,
+  0xae, 0x07, 0xaa, 0x00, 0x75, 0x00, 0xff, 0x0f, 0xdb, 0x00, 0xb6, 0x01,
+  0x70, 0x69, 0x26, 0xd3, 0x9c, 0x07, 0xbc, 0x02, 0x1f, 0x05, 0x9d, 0x00,
+  0xa8, 0x05, 0xee, 0x06, 0x01, 0xf0, 0xbc, 0x05, 0x37, 0x08, 0xbb, 0x06,
+  0x37, 0xfa, 0xb2, 0x00, 0xff, 0x03, 0x98, 0x2e, 0x15, 0xb0, 0x20, 0x26,
+  0x98, 0x2e, 0xf7, 0x00, 0x98, 0x2e, 0xc4, 0xb0, 0x10, 0x30, 0x21, 0x2e,
+  0x59, 0xf0, 0x98, 0x2e, 0xb9, 0x00, 0x98, 0x2e, 0x7a, 0xb4, 0x98, 0x2e,
+  0x89, 0xb4, 0x00, 0x2e, 0x00, 0x2e, 0xd0, 0x2e, 0x98, 0x2e, 0xa7, 0xb0,
+  0x01, 0x2e, 0x58, 0x00, 0x00, 0xb2, 0x1a, 0x2f, 0x00, 0x30, 0x21, 0x2e,
+  0x58, 0x00, 0x47, 0x50, 0x98, 0x2e, 0x65, 0xb0, 0x03, 0x2e, 0x1e, 0x01,
+  0x47, 0x50, 0x02, 0x30, 0x98, 0x2e, 0x28, 0xb5, 0x03, 0x2e, 0x1f, 0x01,
+  0x47, 0x50, 0x12, 0x30, 0x98, 0x2e, 0x28, 0xb5, 0x01, 0x2e, 0x03, 0xf0,
+  0x0d, 0xbc, 0x0f, 0xb8, 0x00, 0x90, 0x02, 0x2f, 0x4f, 0x50, 0x21, 0x2e,
+  0xbc, 0xf0, 0x01, 0x2e, 0x57, 0x00, 0x00, 0xb2, 0x25, 0x2f, 0x00, 0x30,
+  0x21, 0x2e, 0x57, 0x00, 0x49, 0x50, 0x98, 0x2e, 0x65, 0xb0, 0x49, 0x50,
+  0x98, 0x2e, 0xc1, 0xb1, 0x49, 0x50, 0x98, 0x2e, 0x34, 0xb6, 0x49, 0x50,
+  0x4b, 0x52, 0x98, 0x2e, 0xa4, 0xb4, 0x49, 0x50, 0x4d, 0x52, 0x98, 0x2e,
+  0xa4, 0xb4, 0x01, 0x2e, 0x1e, 0x01, 0x0f, 0xbc, 0x0f, 0xb8, 0x00, 0x90,
+  0x4f, 0x50, 0x08, 0x2f, 0x03, 0x2e, 0x1f, 0x01, 0x9f, 0xbc, 0x9f, 0xb8,
+  0x40, 0x90, 0x02, 0x2f, 0x21, 0x2e, 0xbc, 0xf0, 0x02, 0x2d, 0x21, 0x2e,
+  0xba, 0xf0, 0x98, 0x2e, 0xb9, 0x00, 0xaf, 0x2d, 0x10, 0x50, 0xfb, 0x7f,
+  0x21, 0x25, 0x98, 0x2e, 0xf4, 0x01, 0xfb, 0x6f, 0x21, 0x25, 0xf0, 0x5f,
+  0x10, 0x25, 0x80, 0x2e, 0xbe, 0x00, 0x94, 0x01, 0xdd, 0x03, 0xc0, 0xad,
+  0x0b, 0x2f, 0xc0, 0xa8, 0x03, 0x2f, 0xc0, 0x90, 0x07, 0x2f, 0x80, 0xa6,
+  0x05, 0x2f, 0x40, 0xa9, 0x12, 0x2f, 0x40, 0x91, 0x01, 0x2f, 0x00, 0xab,
+  0x0e, 0x2f, 0xc0, 0xac, 0x00, 0x30, 0x55, 0x52, 0x07, 0x2f, 0xc0, 0xa9,
+  0x03, 0x2f, 0xc0, 0x91, 0x03, 0x2f, 0x80, 0xa7, 0x01, 0x2f, 0x40, 0xa1,
+  0x05, 0x2f, 0xc0, 0x2e, 0x17, 0x25, 0x06, 0x25, 0xc0, 0x2e, 0xf0, 0x3f,
+  0x53, 0x52, 0xb8, 0x2e, 0x83, 0x86, 0x01, 0x30, 0x00, 0x30, 0x94, 0x40,
+  0x24, 0x18, 0x06, 0x00, 0x53, 0x0e, 0x4f, 0x02, 0xf9, 0x2f, 0xb8, 0x2e,
+  0x80, 0x2e, 0x18, 0x00, 0x80, 0xa8, 0x03, 0x25, 0x10, 0x2f, 0x80, 0x90,
+  0x01, 0x2f, 0x41, 0x0e, 0x0c, 0x2f, 0xf3, 0x3f, 0x18, 0x05, 0x05, 0x30,
+  0x5d, 0x07, 0x15, 0x0e, 0x03, 0x2f, 0x55, 0x1a, 0x02, 0x2f, 0xcc, 0x0f,
+  0x00, 0x2f, 0x58, 0x04, 0x01, 0x25, 0xb8, 0x2e, 0xb8, 0x2e, 0x63, 0x50,
+  0x41, 0x30, 0x02, 0x40, 0x51, 0x0a, 0x01, 0x42, 0x18, 0x82, 0x57, 0x50,
+  0x60, 0x42, 0x70, 0x3c, 0x59, 0x54, 0x42, 0x42, 0x69, 0x82, 0x82, 0x32,
+  0x43, 0x40, 0x18, 0x08, 0x02, 0x0a, 0x40, 0x42, 0x42, 0x80, 0x02, 0x3f,
+  0x01, 0x40, 0x10, 0x50, 0x4a, 0x08, 0xfb, 0x7f, 0x11, 0x42, 0x0b, 0x31,
+  0x0b, 0x42, 0x3e, 0x80, 0x31, 0x32, 0x01, 0x42, 0x00, 0x2e, 0x01, 0x2e,
+  0x40, 0xf0, 0x13, 0x90, 0x20, 0x2f, 0x03, 0x30, 0x5d, 0x50, 0x5b, 0x54,
+  0x14, 0x35, 0x06, 0x30, 0x61, 0x52, 0x55, 0x32, 0x1d, 0x1a, 0xe3, 0x22,
+  0x18, 0x1a, 0x5f, 0x58, 0xe3, 0x22, 0x04, 0x30, 0xd5, 0x40, 0xb5, 0x0d,
+  0xe1, 0xbe, 0x6f, 0xbb, 0x80, 0x91, 0xa9, 0x0d, 0x01, 0x89, 0xb5, 0x23,
+  0x10, 0xa1, 0xf7, 0x2f, 0xda, 0x0e, 0x14, 0x35, 0xeb, 0x2f, 0x01, 0x2e,
+  0x25, 0x00, 0x70, 0x1a, 0x00, 0x30, 0x21, 0x30, 0x02, 0x2c, 0x08, 0x22,
+  0x30, 0x30, 0x00, 0xb2, 0x06, 0x2f, 0x21, 0x2e, 0x59, 0xf0, 0x98, 0x2e,
+  0xb9, 0x00, 0x00, 0x2e, 0x00, 0x2e, 0xd0, 0x2e, 0xfb, 0x6f, 0xf0, 0x5f,
+  0xb8, 0x2e, 0x70, 0x50, 0x03, 0x2e, 0x22, 0x01, 0xf1, 0x7f, 0x2a, 0x25,
+  0xb9, 0x82, 0xe0, 0x7f, 0xdb, 0x7f, 0x00, 0x30, 0x45, 0x30, 0x32, 0x30,
+  0x03, 0x30, 0x04, 0x30, 0xf6, 0x6f, 0xf2, 0x09, 0xfc, 0x13, 0xc2, 0xab,
+  0xb5, 0x09, 0xc7, 0x23, 0x80, 0xb3, 0xe6, 0x6f, 0xb7, 0x01, 0x00, 0x2e,
+  0x8b, 0x41, 0x4b, 0x42, 0x05, 0x2f, 0xc5, 0x7f, 0x05, 0x30, 0x46, 0x40,
+  0xae, 0x05, 0xc5, 0x6f, 0x46, 0x42, 0x01, 0x80, 0x23, 0xbd, 0xd3, 0xbe,
+  0x03, 0x89, 0x41, 0x82, 0xdf, 0x0c, 0x03, 0xa2, 0xe4, 0x2f, 0xe0, 0x6f,
+  0x91, 0x6f, 0x11, 0x42, 0xc3, 0xb2, 0xa1, 0x6f, 0x11, 0x42, 0x00, 0x2e,
+  0xb1, 0x6f, 0x01, 0x42, 0x06, 0x2f, 0x00, 0x32, 0x03, 0x2e, 0x59, 0xf0,
+  0x08, 0x0a, 0x21, 0x2e, 0x59, 0xf0, 0x06, 0x2d, 0xf1, 0x3d, 0x01, 0x2e,
+  0x59, 0xf0, 0x01, 0x08, 0x21, 0x2e, 0x59, 0xf0, 0xdb, 0x6f, 0x90, 0x5f,
+  0xb8, 0x2e, 0x69, 0x50, 0x05, 0x2e, 0x00, 0xf0, 0x4f, 0x56, 0xd3, 0x0f,
+  0x01, 0x40, 0xf4, 0x33, 0xcc, 0x08, 0x0d, 0x2f, 0xf4, 0x30, 0x94, 0x08,
+  0xb9, 0x88, 0x02, 0xa3, 0x04, 0x2f, 0x67, 0x58, 0x4c, 0x0a, 0x87, 0xa2,
+  0x05, 0x2c, 0xcb, 0x22, 0x4f, 0x54, 0x4a, 0x0a, 0xf2, 0x3b, 0xca, 0x08,
+  0x3c, 0x80, 0x27, 0x2e, 0x59, 0xf0, 0x01, 0x40, 0x01, 0x42, 0xb8, 0x2e,
+  0x01, 0x2e, 0xb1, 0xf0, 0x67, 0x52, 0x01, 0x0a, 0x21, 0x2e, 0xb1, 0xf0,
+  0x01, 0x2e, 0x1e, 0x01, 0x0f, 0xbc, 0x0f, 0xb8, 0x00, 0x90, 0x4f, 0x50,
+  0x08, 0x2f, 0x03, 0x2e, 0x1f, 0x01, 0x9f, 0xbc, 0x9f, 0xb8, 0x40, 0x90,
+  0x02, 0x2f, 0xc0, 0x2e, 0x21, 0x2e, 0xbc, 0xf0, 0xc0, 0x2e, 0x21, 0x2e,
+  0xba, 0xf0, 0x70, 0x50, 0xf7, 0x7f, 0x00, 0x2e, 0x0f, 0x2e, 0xb8, 0xf0,
+  0xf8, 0xbf, 0xff, 0xbb, 0xc0, 0xb3, 0x23, 0x2f, 0xb2, 0x7f, 0x94, 0x7f,
+  0xc6, 0x7f, 0xe5, 0x7f, 0xd3, 0x7f, 0xa1, 0x7f, 0x35, 0x30, 0x05, 0x2e,
+  0x01, 0xf0, 0x2e, 0xbd, 0x2e, 0xbb, 0x6b, 0x58, 0x6e, 0x05, 0x47, 0x56,
+  0x6d, 0x54, 0x11, 0x30, 0x27, 0x41, 0x06, 0x41, 0xf8, 0xbf, 0xbe, 0x0b,
+  0xb5, 0x11, 0xd6, 0x42, 0x03, 0x89, 0x5a, 0x0e, 0xf6, 0x2f, 0x23, 0x2e,
+  0x58, 0x00, 0x4f, 0x52, 0x23, 0x2e, 0xb8, 0xf0, 0xb2, 0x6f, 0xe5, 0x6f,
+  0xd3, 0x6f, 0xa1, 0x6f, 0x94, 0x6f, 0xc6, 0x6f, 0xf7, 0x6f, 0x90, 0x5f,
+  0xc8, 0x2e, 0x60, 0x50, 0xc3, 0x7f, 0xd4, 0x7f, 0xe7, 0x7f, 0xf6, 0x7f,
+  0xb2, 0x7f, 0xa5, 0x7f, 0x36, 0x30, 0x07, 0x2e, 0x01, 0xf0, 0xbe, 0xbd,
+  0xbe, 0xbb, 0x6f, 0x58, 0x77, 0x05, 0x49, 0x56, 0x71, 0x54, 0x27, 0x41,
+  0x06, 0x41, 0xf8, 0xbf, 0xbe, 0x0b, 0xb5, 0x11, 0xd6, 0x42, 0x03, 0x89,
+  0x5a, 0x0e, 0xf6, 0x2f, 0x12, 0x30, 0x25, 0x2e, 0x57, 0x00, 0x02, 0x31,
+  0x25, 0x2e, 0xb8, 0xf0, 0xd4, 0x6f, 0xc3, 0x6f, 0xe7, 0x6f, 0xb2, 0x6f,
+  0xa5, 0x6f, 0xf6, 0x6f, 0xa0, 0x5f, 0xc8, 0x2e, 0x1a, 0x24, 0x26, 0x00,
+  0x80, 0x2e, 0x65, 0x01, 0x70, 0x50, 0x42, 0x8e, 0xd4, 0x7f, 0xf6, 0x7f,
+  0x47, 0x25, 0x1a, 0x18, 0x73, 0x52, 0xf1, 0x00, 0x64, 0x25, 0x01, 0x30,
+  0x39, 0x02, 0x94, 0x41, 0x81, 0x41, 0xe2, 0x7f, 0xbe, 0xbb, 0xbd, 0x8d,
+  0x02, 0xbd, 0xb5, 0x7f, 0x8e, 0xb5, 0xba, 0x0a, 0xc6, 0x7f, 0xab, 0x7f,
+  0x51, 0x25, 0x98, 0x2e, 0xd1, 0x01, 0xd5, 0x6f, 0xe2, 0x6f, 0x2a, 0x18,
+  0x73, 0x54, 0xb2, 0x01, 0x02, 0x30, 0xc4, 0x6f, 0x7a, 0x03, 0x12, 0x41,
+  0x74, 0x25, 0xd0, 0x7f, 0x52, 0xbc, 0xd3, 0x41, 0x6e, 0xba, 0xde, 0xb6,
+  0x20, 0x0b, 0xc7, 0x7f, 0x91, 0x7f, 0x98, 0x2e, 0xd1, 0x01, 0xf2, 0x6f,
+  0xd5, 0x6f, 0xca, 0x16, 0x55, 0x18, 0xdd, 0x18, 0x95, 0x6f, 0xea, 0x18,
+  0x73, 0x5a, 0x31, 0x25, 0x75, 0x01, 0x01, 0x30, 0x20, 0x25, 0x39, 0x02,
+  0x5e, 0xba, 0x82, 0xbc, 0x8e, 0xb6, 0x21, 0x0b, 0x98, 0x2e, 0xd1, 0x01,
+  0xe2, 0x6f, 0xb5, 0x6f, 0x2a, 0x18, 0xe0, 0x7f, 0xf1, 0x7f, 0x04, 0x30,
+  0x73, 0x54, 0xf2, 0x00, 0x7c, 0x02, 0x85, 0x6f, 0xd0, 0x6f, 0x0d, 0x17,
+  0x68, 0x18, 0xe0, 0x18, 0x90, 0x6f, 0xc4, 0x6f, 0xc5, 0x18, 0xeb, 0x6f,
+  0xb2, 0x01, 0x1b, 0x43, 0x02, 0x30, 0x7a, 0x03, 0xfb, 0x6f, 0x3d, 0x8f,
+  0x0b, 0x43, 0x3e, 0xba, 0x12, 0xbd, 0x52, 0xbc, 0x6e, 0xbb, 0xa2, 0x0a,
+  0x9e, 0xb5, 0xde, 0xb6, 0x30, 0x0b, 0xf7, 0x7f, 0x98, 0x2e, 0xd1, 0x01,
+  0xf5, 0x6f, 0x31, 0x25, 0xd1, 0x6f, 0x92, 0x6f, 0xab, 0x6f, 0x50, 0x43,
+  0x43, 0x43, 0x90, 0x5f, 0x53, 0x56, 0x80, 0x2e, 0x00, 0xb0, 0x10, 0x50,
+  0x03, 0x40, 0x19, 0x18, 0x55, 0x56, 0x19, 0x05, 0x36, 0x25, 0xf7, 0x7f,
+  0x4a, 0x17, 0x54, 0x18, 0xec, 0x18, 0x09, 0x17, 0x01, 0x30, 0x0c, 0x07,
+  0xe2, 0x18, 0xde, 0x00, 0xf2, 0x6f, 0x97, 0x02, 0x51, 0x58, 0xdc, 0x00,
+  0x91, 0x02, 0xbf, 0xb8, 0x21, 0xbd, 0x8a, 0x0a, 0xc0, 0x2e, 0x02, 0x42,
+  0xf0, 0x5f, 0x09, 0x2e, 0x1d, 0x01, 0x05, 0x2e, 0x1d, 0x01, 0xa3, 0xbc,
+  0x44, 0xbe, 0x90, 0x50, 0x4f, 0xb9, 0x07, 0x2e, 0x1d, 0x01, 0x4a, 0x25,
+  0x9f, 0xb8, 0x39, 0x8f, 0xb2, 0xbd, 0xf2, 0x7f, 0xbf, 0xb9, 0xeb, 0x7f,
+  0x8a, 0x0a, 0x37, 0x89, 0x0b, 0x30, 0x93, 0x0a, 0x8b, 0x7f, 0xcb, 0x43,
+  0x0b, 0x43, 0x80, 0xb2, 0xd3, 0x7f, 0xc1, 0x7f, 0x90, 0x2e, 0x6c, 0xb2,
+  0x20, 0x25, 0x01, 0x2e, 0x5f, 0x00, 0x01, 0x90, 0x0e, 0x2f, 0x75, 0x52,
+  0x01, 0x2e, 0x5c, 0x00, 0xb4, 0x7f, 0xa2, 0x7f, 0x98, 0x2e, 0x72, 0xb2,
+  0x00, 0x30, 0x21, 0x2e, 0x5f, 0x00, 0xc1, 0x6f, 0xd3, 0x6f, 0xa2, 0x6f,
+  0xb4, 0x6f, 0x0b, 0x30, 0x01, 0x2e, 0x1d, 0x01, 0x06, 0xbc, 0x06, 0xbb,
+  0x57, 0x25, 0x01, 0x2e, 0x1d, 0x01, 0x94, 0xb1, 0x05, 0xbc, 0xb6, 0x7f,
+  0x0f, 0xbb, 0x79, 0x50, 0x80, 0xb3, 0x0f, 0x2f, 0x0d, 0x2e, 0x1d, 0x01,
+  0x7d, 0x5e, 0xb7, 0x09, 0x2d, 0x2e, 0x1d, 0x01, 0x7f, 0x5c, 0x77, 0x5e,
+  0x9b, 0x43, 0x9b, 0x43, 0xdb, 0x43, 0x9b, 0x43, 0x1b, 0x42, 0xcb, 0x43,
+  0x0b, 0x42, 0x8b, 0x43, 0x40, 0xb2, 0x05, 0x2f, 0x77, 0x50, 0x00, 0x2e,
+  0x16, 0x40, 0x0b, 0x40, 0x76, 0x7f, 0x8b, 0x7f, 0xcb, 0x0a, 0x01, 0x2e,
+  0x5c, 0x00, 0x75, 0x52, 0x7b, 0x5c, 0x98, 0x2e, 0xbe, 0xb2, 0x90, 0x6f,
+  0x00, 0xb2, 0x0b, 0x2f, 0xf0, 0x6f, 0x00, 0xb2, 0x08, 0x2f, 0x77, 0x58,
+  0x79, 0x50, 0x12, 0x41, 0x12, 0x42, 0x21, 0x30, 0x04, 0x41, 0x04, 0x42,
+  0x23, 0x2e, 0x5e, 0xf0, 0xc0, 0x6f, 0x00, 0xb2, 0x26, 0x2f, 0x74, 0x6f,
+  0x80, 0x6f, 0x7f, 0x54, 0x88, 0xbd, 0xc8, 0xb8, 0x4b, 0x0a, 0x94, 0x42,
+  0x91, 0x42, 0x90, 0x42, 0x88, 0xba, 0x77, 0x52, 0xf3, 0x6f, 0x54, 0x42,
+  0x85, 0x42, 0xc0, 0x90, 0x40, 0x42, 0x15, 0x2f, 0x79, 0x52, 0x00, 0x2e,
+  0x52, 0x40, 0x41, 0x40, 0xa2, 0x04, 0x41, 0x06, 0x40, 0xaa, 0x04, 0x2f,
+  0x40, 0x90, 0x0b, 0x2f, 0xb1, 0x6f, 0x4a, 0x0f, 0x08, 0x2f, 0xb2, 0x6f,
+  0x80, 0xb2, 0x05, 0x2f, 0x79, 0x54, 0x21, 0x30, 0x94, 0x42, 0x80, 0x42,
+  0x23, 0x2e, 0x5e, 0xf0, 0xd0, 0x6f, 0x00, 0xb2, 0x13, 0x2f, 0x01, 0x2e,
+  0x5b, 0x00, 0x09, 0x2e, 0x81, 0x00, 0x04, 0x1a, 0x0d, 0x2f, 0x81, 0x50,
+  0x29, 0x2e, 0x5b, 0x00, 0x24, 0x42, 0x44, 0x30, 0x02, 0x40, 0x02, 0x42,
+  0x09, 0x80, 0x00, 0x2e, 0x04, 0x42, 0x03, 0x2d, 0x10, 0x30, 0x21, 0x2e,
+  0x5f, 0x00, 0xeb, 0x6f, 0x70, 0x5f, 0xb8, 0x2e, 0x09, 0x86, 0x51, 0x54,
+  0xe4, 0x40, 0xc3, 0x80, 0x94, 0x04, 0xc3, 0x40, 0x13, 0x05, 0x05, 0x40,
+  0x25, 0x05, 0x8a, 0x17, 0x73, 0x30, 0x73, 0x09, 0x8c, 0x17, 0xf3, 0x08,
+  0xe3, 0x00, 0x4c, 0x82, 0x15, 0x01, 0xb3, 0xb5, 0x53, 0x42, 0x8b, 0x16,
+  0x43, 0xb6, 0x52, 0x42, 0x4c, 0x17, 0x54, 0x42, 0x55, 0x42, 0x53, 0x42,
+  0x52, 0x42, 0x54, 0x42, 0x45, 0x42, 0x6d, 0x82, 0x83, 0x54, 0x52, 0x42,
+  0x10, 0x50, 0x85, 0x54, 0x52, 0x42, 0xfb, 0x7f, 0x22, 0x30, 0x87, 0x56,
+  0x43, 0x42, 0x44, 0x82, 0x0b, 0x30, 0x52, 0x42, 0x5b, 0x42, 0x7c, 0x84,
+  0x4b, 0x42, 0x35, 0x82, 0x90, 0x80, 0x8b, 0x42, 0x0b, 0x42, 0x35, 0x80,
+  0x04, 0x30, 0x0b, 0x42, 0x37, 0x80, 0x15, 0x30, 0x60, 0x25, 0x98, 0x2e,
+  0xb1, 0xb2, 0x8b, 0x83, 0xfb, 0x6f, 0x65, 0x42, 0xc0, 0x2e, 0x44, 0x42,
+  0xf0, 0x5f, 0x05, 0x80, 0x02, 0x30, 0x51, 0x82, 0x02, 0x42, 0x13, 0x30,
+  0x41, 0x40, 0x4b, 0x08, 0x89, 0x54, 0x3e, 0x80, 0x51, 0x14, 0xc0, 0x2e,
+  0x01, 0x42, 0x00, 0x2e, 0x40, 0x51, 0xd1, 0x7f, 0x12, 0x25, 0x02, 0x30,
+  0x42, 0x43, 0x32, 0x30, 0x82, 0x43, 0xc6, 0x7f, 0xe5, 0x7f, 0xb4, 0x7f,
+  0xa3, 0x7f, 0x90, 0x7f, 0x8b, 0x7f, 0x98, 0x2e, 0xc6, 0x01, 0xc0, 0x7e,
+  0x00, 0xac, 0x01, 0x2f, 0x53, 0x50, 0xc0, 0x7e, 0x00, 0x2e, 0x90, 0x6f,
+  0x09, 0x8a, 0xd1, 0x6f, 0x75, 0x7f, 0x4c, 0x82, 0x63, 0x41, 0x65, 0x7f,
+  0x11, 0x7f, 0x00, 0x2e, 0x64, 0x41, 0x44, 0x85, 0x52, 0x7f, 0x45, 0x7f,
+  0x00, 0x2e, 0xa6, 0x40, 0x80, 0x40, 0x32, 0x7f, 0x82, 0x8e, 0xc2, 0x6e,
+  0x45, 0x41, 0xf0, 0x7f, 0x27, 0x7f, 0x02, 0x7f, 0x98, 0x2e, 0x38, 0xb1,
+  0x23, 0x6f, 0xd1, 0x6f, 0xc2, 0x40, 0xf9, 0x86, 0x23, 0x7f, 0x80, 0xb2,
+  0xe0, 0x7e, 0x0f, 0x2f, 0x32, 0x6f, 0x64, 0x6f, 0x82, 0x40, 0xf2, 0x7f,
+  0x50, 0x82, 0x42, 0x6f, 0x50, 0x6f, 0x73, 0x6f, 0x85, 0x40, 0xc3, 0x40,
+  0x04, 0x41, 0x06, 0x40, 0xe2, 0x6e, 0x98, 0x2e, 0x38, 0xb1, 0xe0, 0x7e,
+  0xf3, 0x31, 0x10, 0x6f, 0x36, 0x80, 0xe1, 0x6e, 0x02, 0x40, 0x71, 0x7f,
+  0x51, 0x04, 0x02, 0x30, 0x40, 0xa8, 0x91, 0x04, 0x4a, 0x22, 0x89, 0x16,
+  0x93, 0x08, 0x4a, 0x00, 0x95, 0xb4, 0x09, 0x18, 0x8e, 0x16, 0x13, 0x30,
+  0x93, 0x08, 0x21, 0x6f, 0x60, 0x7f, 0x4d, 0x86, 0x02, 0x80, 0xb2, 0x00,
+  0x41, 0x40, 0x21, 0xb5, 0x50, 0x7f, 0x43, 0x7f, 0x98, 0x2e, 0xa7, 0xb1,
+  0x40, 0x6f, 0x62, 0x6f, 0x55, 0x6f, 0x13, 0x40, 0x84, 0x40, 0x01, 0x40,
+  0x45, 0x41, 0x42, 0xbe, 0x1d, 0x18, 0x4c, 0x04, 0x31, 0x0f, 0x04, 0x8a,
+  0xc0, 0x6f, 0x11, 0x30, 0x02, 0x2f, 0x00, 0x2e, 0x03, 0x2c, 0x01, 0x42,
+  0x23, 0x30, 0x03, 0x42, 0x00, 0x2e, 0xd6, 0x6f, 0x44, 0x41, 0x8a, 0x87,
+  0x76, 0x8b, 0x00, 0xb3, 0x53, 0x7f, 0x15, 0x2f, 0x04, 0x6f, 0x8b, 0x5e,
+  0x8b, 0x8d, 0xe7, 0x01, 0xc0, 0xa5, 0x84, 0x41, 0x01, 0x2f, 0x00, 0xa1,
+  0x03, 0x2f, 0xc0, 0xad, 0x08, 0x2f, 0x00, 0xa5, 0x06, 0x2f, 0xc6, 0x40,
+  0x81, 0x8d, 0x07, 0x30, 0x3c, 0x05, 0xd6, 0x42, 0x04, 0x2c, 0xc4, 0x42,
+  0x02, 0x2c, 0x07, 0x30, 0x07, 0x30, 0x86, 0x86, 0x94, 0x6f, 0xd7, 0x7e,
+  0x0e, 0x8d, 0x00, 0x40, 0x74, 0x89, 0xc7, 0x40, 0x02, 0xb2, 0xf9, 0x29,
+  0x45, 0x41, 0x86, 0x41, 0xbe, 0x80, 0x21, 0x41, 0x75, 0x23, 0x82, 0x40,
+  0xc7, 0x42, 0x45, 0x7f, 0x34, 0x7f, 0x20, 0x7f, 0x98, 0x2e, 0xa7, 0xb1,
+  0x31, 0x6f, 0x60, 0x6f, 0x24, 0x6f, 0x22, 0x40, 0x05, 0x41, 0x43, 0x40,
+  0x13, 0x01, 0x43, 0x86, 0xac, 0x0f, 0xd1, 0x6f, 0x30, 0x7f, 0x00, 0x2f,
+  0x44, 0x42, 0x48, 0x8a, 0x41, 0x88, 0xe1, 0x40, 0x13, 0x7f, 0x04, 0x7f,
+  0xf5, 0x7e, 0x98, 0x2e, 0xa7, 0xb1, 0x11, 0x6f, 0x60, 0x6f, 0x34, 0x6f,
+  0x42, 0x40, 0x03, 0x40, 0x9a, 0x04, 0x04, 0x41, 0x43, 0x82, 0xa2, 0x0e,
+  0x03, 0x6f, 0x00, 0x2f, 0xc2, 0x42, 0x00, 0x2e, 0x41, 0x40, 0x72, 0x6f,
+  0x98, 0x2e, 0xa7, 0xb1, 0x25, 0x6f, 0x72, 0x6f, 0x53, 0x41, 0x93, 0x0e,
+  0xd1, 0x6f, 0x46, 0x80, 0x1b, 0x30, 0x03, 0x30, 0x0c, 0x2f, 0x04, 0x40,
+  0x00, 0x91, 0x42, 0x42, 0x08, 0x2f, 0xf6, 0x6e, 0x44, 0x6f, 0x86, 0x41,
+  0xb4, 0x0e, 0x03, 0x2f, 0x02, 0x88, 0xdb, 0x7e, 0x03, 0x43, 0x0b, 0x42,
+  0x46, 0x8d, 0x44, 0x41, 0x47, 0x80, 0x05, 0x6f, 0x94, 0x0f, 0x76, 0x7f,
+  0x60, 0x7f, 0x02, 0x2f, 0x45, 0x89, 0x42, 0x43, 0x03, 0x43, 0x49, 0x88,
+  0xa5, 0x6f, 0x40, 0x91, 0xa4, 0x7f, 0x15, 0x30, 0xe2, 0x6f, 0xd3, 0x6e,
+  0x03, 0x2f, 0x04, 0x30, 0x83, 0x42, 0x80, 0x2e, 0x62, 0xb4, 0x04, 0x40,
+  0x25, 0x29, 0x04, 0x42, 0x83, 0x42, 0x45, 0x82, 0x94, 0x6f, 0x04, 0x85,
+  0xc0, 0xb2, 0x90, 0x2e, 0x4e, 0xb4, 0x15, 0x87, 0x3c, 0x8c, 0xc4, 0x40,
+  0x46, 0x7f, 0xc2, 0x86, 0x07, 0x40, 0x86, 0x41, 0xf4, 0xbf, 0x00, 0xb3,
+  0x0c, 0x2f, 0x90, 0x6f, 0x16, 0x80, 0x46, 0x25, 0x00, 0x40, 0x57, 0x25,
+  0x04, 0x18, 0xae, 0x0e, 0x10, 0x30, 0x06, 0x30, 0x75, 0x25, 0x46, 0x23,
+  0x60, 0x6f, 0x64, 0x25, 0xc4, 0x40, 0xfa, 0x86, 0x00, 0xb3, 0x33, 0x7f,
+  0x09, 0x2f, 0x93, 0x6f, 0xd8, 0x88, 0x53, 0x6f, 0x04, 0x41, 0xc3, 0x40,
+  0xdc, 0x0e, 0x13, 0x30, 0x04, 0x30, 0xdc, 0x22, 0xb3, 0x25, 0x40, 0xb3,
+  0x02, 0x2f, 0x3b, 0x25, 0xc0, 0x90, 0x05, 0x2f, 0x91, 0x6f, 0xd0, 0x6f,
+  0x98, 0x2e, 0xb1, 0xb2, 0x4d, 0x2c, 0x04, 0x30, 0x8d, 0x88, 0x43, 0x40,
+  0x82, 0x40, 0x54, 0x7f, 0xda, 0x0f, 0x04, 0x30, 0x08, 0x2f, 0xc1, 0x80,
+  0x40, 0x42, 0xc2, 0x0f, 0x02, 0x2f, 0x00, 0x30, 0xc0, 0x7e, 0x1b, 0x2d,
+  0xc0, 0x7e, 0x19, 0x2d, 0xe1, 0xbc, 0x92, 0x6f, 0x4f, 0x04, 0x90, 0x84,
+  0x40, 0xa8, 0x21, 0x05, 0x83, 0x40, 0x4c, 0x22, 0x4b, 0x0e, 0xb6, 0x84,
+  0x21, 0x30, 0x02, 0x2f, 0x11, 0x30, 0x04, 0x2c, 0xc1, 0x7e, 0xe3, 0x6f,
+  0xc1, 0x7e, 0xc1, 0x42, 0x00, 0x2e, 0x00, 0x40, 0x81, 0x40, 0x04, 0xbd,
+  0x40, 0x6f, 0x98, 0x2e, 0xa7, 0xb1, 0x50, 0x6f, 0x11, 0x30, 0x02, 0x40,
+  0x51, 0x08, 0xc3, 0x6e, 0x03, 0x80, 0x99, 0x15, 0x0b, 0x40, 0xb1, 0x6f,
+  0xd0, 0x6f, 0xb6, 0x7f, 0x5b, 0x7f, 0x04, 0x30, 0x59, 0x54, 0x03, 0x30,
+  0x11, 0x2c, 0x14, 0x80, 0x55, 0x6f, 0x06, 0x40, 0x75, 0x01, 0x58, 0xbb,
+  0x6a, 0x09, 0x05, 0x42, 0xc1, 0x86, 0x47, 0x40, 0x51, 0x25, 0xbe, 0x01,
+  0x56, 0x43, 0x00, 0x2e, 0x46, 0x41, 0xf4, 0x03, 0xb6, 0x6f, 0x47, 0x43,
+  0x5e, 0x0e, 0xed, 0x2f, 0x31, 0x6f, 0x60, 0x6f, 0x42, 0x40, 0x15, 0x30,
+  0x02, 0x82, 0x95, 0x08, 0x04, 0x42, 0x52, 0x42, 0x02, 0x2c, 0x44, 0x42,
+  0x04, 0x30, 0x3e, 0x8e, 0x91, 0x6f, 0x4f, 0x8c, 0x02, 0x40, 0x83, 0x41,
+  0xb5, 0x8d, 0x93, 0x0e, 0xd0, 0x6f, 0x01, 0x2f, 0x98, 0x2e, 0xb1, 0xb2,
+  0x00, 0x2e, 0xc0, 0x41, 0x81, 0x41, 0xc1, 0x0f, 0xc0, 0x6f, 0x01, 0x2f,
+  0x04, 0x42, 0x00, 0x2e, 0x70, 0x6f, 0x3c, 0x82, 0x00, 0x40, 0x41, 0x40,
+  0x89, 0x16, 0x95, 0x08, 0x4a, 0x00, 0x04, 0xbc, 0x91, 0xb4, 0x01, 0x0e,
+  0xe0, 0x6f, 0x07, 0x2f, 0xa1, 0x6f, 0x00, 0x2e, 0x41, 0x40, 0x40, 0xb2,
+  0x02, 0x2f, 0xa1, 0x6f, 0x05, 0x42, 0x44, 0x42, 0x00, 0x2e, 0x8b, 0x6f,
+  0xc0, 0x5e, 0xb8, 0x2e, 0x10, 0x50, 0x8d, 0x52, 0x4b, 0x50, 0xfb, 0x7f,
+  0x98, 0x2e, 0x98, 0xb4, 0x4b, 0x52, 0x45, 0x82, 0x10, 0x30, 0x50, 0x42,
+  0x60, 0x30, 0xfb, 0x6f, 0xc0, 0x2e, 0x40, 0x42, 0xf0, 0x5f, 0x10, 0x50,
+  0x8f, 0x52, 0x4d, 0x50, 0xfb, 0x7f, 0x98, 0x2e, 0x98, 0xb4, 0x4d, 0x52,
+  0x45, 0x82, 0x00, 0x30, 0x50, 0x42, 0x70, 0x30, 0xfb, 0x6f, 0xc0, 0x2e,
+  0x40, 0x42, 0xf0, 0x5f, 0x12, 0x30, 0x12, 0x42, 0x02, 0x30, 0x12, 0x42,
+  0x12, 0x42, 0x12, 0x42, 0x02, 0x42, 0x03, 0x80, 0x41, 0x84, 0x11, 0x42,
+  0x02, 0x42, 0xb8, 0x2e, 0x48, 0x86, 0x90, 0x50, 0xc4, 0x40, 0x42, 0x84,
+  0xf2, 0x7f, 0x5a, 0x25, 0x02, 0x41, 0xa2, 0xbf, 0x77, 0x85, 0x06, 0x41,
+  0xff, 0xbb, 0x87, 0x42, 0x61, 0xbf, 0x07, 0x41, 0x6f, 0xbb, 0x86, 0x7f,
+  0x7f, 0xbb, 0x96, 0x7f, 0xfe, 0x86, 0x86, 0x40, 0x80, 0x91, 0xc3, 0x40,
+  0xd3, 0x7f, 0xe0, 0x7f, 0x13, 0x30, 0x05, 0x2f, 0x86, 0x6f, 0x80, 0x91,
+  0x02, 0x2f, 0x96, 0x6f, 0x80, 0xb3, 0x60, 0x2f, 0x61, 0x25, 0x57, 0x40,
+  0xc1, 0x91, 0xc1, 0x7f, 0x0f, 0x2f, 0x01, 0x30, 0x81, 0x43, 0x00, 0x2e,
+  0xf2, 0x6f, 0x13, 0x40, 0x93, 0x42, 0x00, 0x2e, 0x13, 0x40, 0x93, 0x42,
+  0x00, 0x2e, 0x00, 0x40, 0x80, 0x42, 0xbd, 0x80, 0xc0, 0x2e, 0x01, 0x42,
+  0x70, 0x5f, 0x87, 0x83, 0x7a, 0x8d, 0x45, 0x40, 0x7b, 0x82, 0x45, 0x41,
+  0x04, 0x41, 0xd5, 0xbf, 0x43, 0xbe, 0xc3, 0xba, 0xa5, 0x7f, 0x75, 0xba,
+  0xb6, 0x7f, 0x05, 0x30, 0x97, 0x40, 0xc0, 0xb3, 0x09, 0x2f, 0x06, 0x40,
+  0x47, 0x40, 0xb7, 0x05, 0x07, 0x30, 0x80, 0xa9, 0xfe, 0x05, 0xb7, 0x23,
+  0x74, 0x0f, 0x5d, 0x23, 0xb6, 0x6f, 0x41, 0x82, 0x01, 0x80, 0x56, 0x0e,
+  0xee, 0x2f, 0x40, 0x40, 0x28, 0x1a, 0xc4, 0x6f, 0xe0, 0x6f, 0xf2, 0x6f,
+  0x02, 0x2f, 0x03, 0x30, 0x19, 0x2c, 0x03, 0x43, 0x05, 0x41, 0x6b, 0x29,
+  0xa6, 0x6f, 0x05, 0x43, 0x6e, 0x0e, 0x11, 0x2f, 0xd4, 0x6f, 0x00, 0xb3,
+  0x03, 0x2f, 0x3f, 0x89, 0xdc, 0x14, 0x27, 0x2e, 0x5e, 0xf0, 0x40, 0x25,
+  0x32, 0x25, 0x15, 0x41, 0xd5, 0x42, 0x00, 0x2e, 0x15, 0x41, 0xd5, 0x42,
+  0x00, 0x2e, 0x04, 0x41, 0xc4, 0x42, 0x00, 0x2e, 0x00, 0x2e, 0x41, 0x40,
+  0x40, 0x90, 0x09, 0x2f, 0x11, 0x40, 0x91, 0x42, 0x00, 0x2e, 0x11, 0x40,
+  0x91, 0x42, 0x00, 0x2e, 0x00, 0x40, 0x02, 0x2c, 0x80, 0x42, 0x43, 0x42,
+  0x70, 0x5f, 0xb8, 0x2e, 0xb0, 0x50, 0x3a, 0x25, 0xf5, 0x86, 0x91, 0x58,
+  0xc4, 0x42, 0x15, 0x30, 0x93, 0x58, 0x4d, 0x09, 0x81, 0x90, 0x64, 0x7f,
+  0xf2, 0x7f, 0xeb, 0x7f, 0x02, 0x2f, 0x40, 0xb3, 0x90, 0x2e, 0x05, 0xb6,
+  0x15, 0x0b, 0x00, 0xb3, 0x90, 0x2e, 0x05, 0xb6, 0x9a, 0x00, 0xe3, 0x30,
+  0xcb, 0x08, 0x81, 0x40, 0x44, 0x84, 0xb1, 0xba, 0x46, 0x86, 0x49, 0x8e,
+  0x97, 0x5c, 0xc2, 0x7f, 0x02, 0x84, 0x07, 0x25, 0xd3, 0x7f, 0x2b, 0x2e,
+  0xa9, 0x00, 0x84, 0x40, 0xe3, 0x41, 0xe3, 0x04, 0xc4, 0x41, 0xc3, 0x43,
+  0x2e, 0x18, 0x95, 0x5a, 0x8b, 0x40, 0x0b, 0x42, 0xb5, 0x00, 0x99, 0x5a,
+  0xb2, 0x7f, 0x3a, 0x80, 0x95, 0x00, 0x05, 0x40, 0x41, 0x8b, 0x05, 0x42,
+  0x03, 0x8a, 0xa2, 0x7f, 0x43, 0x84, 0x40, 0x41, 0x7b, 0x8b, 0x85, 0x7f,
+  0x00, 0xb2, 0xdc, 0x05, 0x91, 0x7f, 0x04, 0x2f, 0xc3, 0x6f, 0x00, 0x2e,
+  0xc4, 0x40, 0x01, 0x89, 0xc4, 0x42, 0x47, 0x86, 0x66, 0x41, 0x75, 0x7f,
+  0x45, 0x88, 0x42, 0x82, 0x3e, 0x0f, 0x45, 0x41, 0x34, 0x2f, 0x46, 0x40,
+  0x3e, 0x0e, 0x26, 0x2f, 0x85, 0x40, 0xc1, 0x33, 0xa9, 0x0e, 0x01, 0x30,
+  0x02, 0x2f, 0xc3, 0x40, 0xc0, 0xb2, 0x1b, 0x2f, 0x82, 0x34, 0xaa, 0x0e,
+  0x31, 0x2f, 0x01, 0x41, 0x7f, 0x82, 0x43, 0xa2, 0x02, 0x30, 0x02, 0x2f,
+  0x00, 0x2e, 0x0c, 0x2c, 0x01, 0x30, 0x00, 0xb2, 0xd0, 0x6f, 0x11, 0x30,
+  0x01, 0x2f, 0x02, 0x42, 0x02, 0x2d, 0x01, 0x42, 0x01, 0x30, 0xc0, 0x6f,
+  0x00, 0x2e, 0x02, 0x42, 0x3e, 0x81, 0x04, 0x86, 0x02, 0x42, 0x02, 0x43,
+  0xc2, 0x42, 0x19, 0x2d, 0xc0, 0x33, 0x80, 0x42, 0x16, 0x2d, 0xa0, 0x6f,
+  0x28, 0x04, 0x38, 0x1e, 0x40, 0x42, 0x11, 0x30, 0x90, 0x6f, 0x22, 0x30,
+  0x98, 0x2e, 0x08, 0xb6, 0x0c, 0x2c, 0x01, 0x30, 0xa1, 0x6f, 0xa9, 0x00,
+  0x90, 0x6f, 0x01, 0x82, 0xba, 0x1c, 0x42, 0x42, 0x21, 0x30, 0x12, 0x30,
+  0x98, 0x2e, 0x08, 0xb6, 0x01, 0x30, 0x72, 0x6f, 0xd4, 0xb1, 0xf5, 0xbd,
+  0x6b, 0xba, 0x9f, 0x5a, 0x80, 0x40, 0x05, 0x18, 0xf5, 0xbe, 0xe3, 0x0a,
+  0xeb, 0xbb, 0x3d, 0x0b, 0x80, 0x6f, 0xe3, 0x00, 0x04, 0x40, 0x63, 0x05,
+  0xa1, 0x58, 0x2c, 0x18, 0xf5, 0xbe, 0x83, 0x42, 0xeb, 0xbb, 0xfd, 0x0b,
+  0xb2, 0x6f, 0x5a, 0x01, 0xdf, 0x01, 0x7d, 0x1f, 0x15, 0x42, 0x9a, 0x04,
+  0x05, 0x40, 0x5d, 0x05, 0x2c, 0x18, 0x75, 0xbe, 0xeb, 0xba, 0x2c, 0x0b,
+  0xdc, 0x04, 0x9a, 0x1c, 0x02, 0x42, 0x04, 0x80, 0x00, 0x2e, 0x00, 0x40,
+  0x00, 0xb2, 0x10, 0x2f, 0xc2, 0x6f, 0xc0, 0x33, 0x82, 0x40, 0x90, 0x0e,
+  0x0b, 0x2f, 0xd1, 0x6f, 0x7e, 0x88, 0x03, 0x81, 0x3c, 0x84, 0x0b, 0x30,
+  0x82, 0x86, 0x4b, 0x42, 0x0b, 0x42, 0x0b, 0x43, 0x8b, 0x42, 0xcb, 0x42,
+  0x21, 0x30, 0x42, 0xb2, 0x02, 0x30, 0x9d, 0x50, 0x02, 0x22, 0x41, 0xb2,
+  0x9b, 0x52, 0x08, 0x22, 0xf1, 0x6f, 0x40, 0x90, 0x11, 0x30, 0x06, 0x2f,
+  0x22, 0x30, 0x02, 0x08, 0x00, 0xb2, 0x08, 0x2f, 0x23, 0x2e, 0x5e, 0xf0,
+  0x06, 0x2d, 0x01, 0x08, 0x00, 0xb2, 0x02, 0x2f, 0x00, 0x31, 0x21, 0x2e,
+  0x5e, 0xf0, 0xeb, 0x6f, 0x50, 0x5f, 0xb8, 0x2e, 0x07, 0x86, 0xfc, 0x88,
+  0xc6, 0x40, 0x05, 0x41, 0x31, 0x1a, 0x12, 0x2f, 0x80, 0x91, 0x22, 0x2f,
+  0xc1, 0x33, 0x29, 0x0f, 0x0a, 0x2f, 0x06, 0x80, 0x00, 0x2e, 0x00, 0x40,
+  0x00, 0xb2, 0x01, 0x2f, 0x44, 0xa9, 0x03, 0x2f, 0x00, 0x30, 0xc0, 0x42,
+  0x00, 0x43, 0xb8, 0x2e, 0xc2, 0x42, 0x01, 0x43, 0xb8, 0x2e, 0xc1, 0x33,
+  0xa9, 0x0e, 0x0e, 0x2f, 0x43, 0x3c, 0xeb, 0x00, 0xcc, 0xa8, 0x0a, 0x2f,
+  0x05, 0x86, 0xc2, 0x80, 0xc3, 0x40, 0x02, 0x42, 0x3c, 0x84, 0xc1, 0x80,
+  0x81, 0x42, 0x82, 0x84, 0xc0, 0x2e, 0x80, 0x42, 0x00, 0x2e, 0xb8, 0x2e,
+  0x05, 0x2e, 0x20, 0x01, 0x11, 0x30, 0x20, 0x50, 0x91, 0x08, 0xf0, 0x7f,
+  0x80, 0xb2, 0xeb, 0x7f, 0x13, 0x2f, 0x01, 0x2e, 0x74, 0x00, 0x01, 0x90,
+  0x02, 0x30, 0xa3, 0x50, 0x03, 0x2f, 0x25, 0x2e, 0x74, 0x00, 0x98, 0x2e,
+  0xad, 0xb7, 0xf2, 0x6f, 0xa3, 0x52, 0x98, 0x2e, 0x57, 0xb6, 0x00, 0xb2,
+  0x06, 0x2f, 0x80, 0x30, 0x21, 0x2e, 0x5e, 0xf0, 0x03, 0x2d, 0x10, 0x30,
+  0x21, 0x2e, 0x74, 0x00, 0xeb, 0x6f, 0xe0, 0x5f, 0xb8, 0x2e, 0x30, 0x51,
+  0x42, 0x8a, 0xe1, 0x7f, 0x83, 0x88, 0xdb, 0x7f, 0xc5, 0x7f, 0x1a, 0x25,
+  0x05, 0x25, 0x93, 0x40, 0x06, 0x40, 0xb3, 0x01, 0x16, 0x42, 0xcb, 0x16,
+  0x06, 0x40, 0xf3, 0x02, 0x13, 0x42, 0x54, 0x0e, 0xf5, 0x2f, 0x04, 0x40,
+  0x12, 0x30, 0xa2, 0x28, 0x02, 0x42, 0x88, 0xa0, 0x00, 0x30, 0x90, 0x2e,
+  0xa9, 0xb7, 0x6d, 0x84, 0x73, 0x88, 0x92, 0x7f, 0x70, 0x7f, 0x84, 0x7f,
+  0xa2, 0x7f, 0x70, 0x86, 0xb5, 0x7f, 0x63, 0x7f, 0x75, 0x30, 0xa5, 0x52,
+  0xa7, 0x54, 0xbd, 0x50, 0xaf, 0x58, 0xb7, 0x6f, 0xf4, 0x7f, 0x51, 0x7f,
+  0x00, 0x2e, 0xd6, 0x41, 0xd4, 0x41, 0xb7, 0x7f, 0xcc, 0x17, 0x7d, 0x09,
+  0x75, 0x01, 0x06, 0x30, 0x26, 0x03, 0x4d, 0xbe, 0xd3, 0xba, 0x6c, 0x0b,
+  0x28, 0x0e, 0x05, 0x22, 0x2a, 0x0f, 0x90, 0x22, 0xd2, 0x42, 0x43, 0x7f,
+  0x32, 0x7f, 0x00, 0x2e, 0xa9, 0x5a, 0xab, 0x58, 0xad, 0x5c, 0xa9, 0x56,
+  0x98, 0x2e, 0x38, 0xb1, 0x91, 0x6f, 0x32, 0x6f, 0x50, 0x42, 0x91, 0x7f,
+  0xb3, 0x30, 0x10, 0x25, 0x98, 0x2e, 0xdb, 0xb7, 0x71, 0x6f, 0x88, 0x28,
+  0x43, 0x6f, 0x80, 0x6f, 0x72, 0x7f, 0x58, 0x0e, 0x51, 0x6f, 0x44, 0x82,
+  0xa7, 0x54, 0xbd, 0x50, 0x75, 0x30, 0xaf, 0x58, 0xcd, 0x2f, 0xb1, 0x6f,
+  0x46, 0x84, 0xe1, 0x6f, 0x4e, 0x80, 0x81, 0x40, 0xb2, 0x7f, 0x90, 0x7f,
+  0x12, 0x30, 0x98, 0x2e, 0xcc, 0xb7, 0xb1, 0x6f, 0x7c, 0x8a, 0xa2, 0x6f,
+  0xb5, 0x7f, 0x40, 0x42, 0x98, 0x2e, 0xf4, 0x01, 0x95, 0xbc, 0x0b, 0xb9,
+  0x51, 0x0a, 0x62, 0x6f, 0xa1, 0x7f, 0x98, 0x2e, 0xf4, 0x01, 0x95, 0xbc,
+  0x0b, 0xb9, 0x11, 0x0a, 0xa1, 0x6f, 0x49, 0x17, 0x48, 0x18, 0x88, 0x16,
+  0xe8, 0x18, 0xd1, 0x18, 0x27, 0x25, 0x16, 0x25, 0x80, 0x7f, 0x98, 0x2e,
+  0xbe, 0x00, 0xb5, 0x6f, 0xe1, 0x6f, 0x43, 0x41, 0x4b, 0x84, 0x4c, 0x8c,
+  0xb0, 0x7f, 0x62, 0x7f, 0x4a, 0x88, 0x7e, 0x8b, 0xc0, 0x90, 0x56, 0x7f,
+  0x13, 0x2f, 0x45, 0x7f, 0x34, 0x7f, 0xb3, 0x30, 0xb1, 0x52, 0xb2, 0x6f,
+  0x98, 0x2e, 0xdb, 0xb7, 0x71, 0x6f, 0x88, 0x0e, 0x34, 0x6f, 0x45, 0x6f,
+  0xe1, 0x6f, 0x06, 0x2f, 0x34, 0x25, 0x1b, 0x30, 0x10, 0x6f, 0x22, 0x6f,
+  0xdb, 0x42, 0xd0, 0x42, 0xc2, 0x42, 0x02, 0x30, 0x00, 0x6f, 0x00, 0xa8,
+  0x90, 0x05, 0x13, 0x6f, 0x86, 0x23, 0xc0, 0xa8, 0xd3, 0x05, 0xdf, 0x23,
+  0xb7, 0x05, 0xb3, 0x5e, 0x37, 0x0f, 0x4d, 0x8c, 0x07, 0x30, 0x19, 0x2f,
+  0x44, 0x7f, 0x00, 0x2e, 0x24, 0x6f, 0xb3, 0x5e, 0xa7, 0x0e, 0x44, 0x6f,
+  0x07, 0x30, 0x11, 0x2f, 0xc7, 0x5e, 0xdf, 0x00, 0xc1, 0x5e, 0x5f, 0x0e,
+  0x02, 0x2f, 0x00, 0x2e, 0x0b, 0x2c, 0x07, 0x30, 0xc9, 0x56, 0x03, 0x00,
+  0xc3, 0x56, 0x43, 0x0e, 0x02, 0x2f, 0x00, 0x2e, 0x03, 0x2c, 0x07, 0x30,
+  0x82, 0x43, 0x17, 0x30, 0x41, 0x86, 0xc0, 0x91, 0x0e, 0x2f, 0xc0, 0x40,
+  0x01, 0x90, 0x09, 0x2f, 0x80, 0x41, 0x14, 0x30, 0x04, 0x28, 0x80, 0x43,
+  0x06, 0xa0, 0x03, 0x2f, 0xc8, 0x80, 0xbb, 0x58, 0xc2, 0x42, 0x04, 0x42,
+  0x66, 0x2c, 0x00, 0x30, 0x90, 0x6f, 0x00, 0x2e, 0x00, 0x40, 0x00, 0xa8,
+  0x00, 0x30, 0x5e, 0x2f, 0x00, 0x41, 0x00, 0xb2, 0x00, 0x30, 0x5a, 0x2f,
+  0x49, 0x82, 0xb2, 0x6f, 0x43, 0x7f, 0xb5, 0x7f, 0x94, 0x7f, 0xb3, 0x30,
+  0x41, 0x40, 0x98, 0x2e, 0xdb, 0xb7, 0x71, 0x6f, 0x88, 0x0f, 0xb5, 0x6f,
+  0xe1, 0x6f, 0x02, 0x30, 0x00, 0x30, 0x4a, 0x2f, 0x80, 0x6f, 0xc5, 0x58,
+  0x04, 0x00, 0xbf, 0x58, 0x44, 0x0e, 0x02, 0x2f, 0x00, 0x2e, 0x43, 0x2c,
+  0x00, 0x30, 0xa0, 0x6f, 0xb5, 0x58, 0x84, 0x0e, 0x00, 0x30, 0x3c, 0x2f,
+  0xb7, 0x54, 0x21, 0x6f, 0xb5, 0x7f, 0x98, 0x2e, 0xcc, 0xb7, 0x10, 0x25,
+  0xb3, 0x30, 0x21, 0x25, 0x98, 0x2e, 0xdb, 0xb7, 0x02, 0x6f, 0xa0, 0x7f,
+  0xb3, 0x30, 0x12, 0x25, 0x98, 0x2e, 0xdb, 0xb7, 0x12, 0x6f, 0x80, 0x7f,
+  0xb3, 0x30, 0x12, 0x25, 0x98, 0x2e, 0xdb, 0xb7, 0x81, 0x6f, 0x88, 0x28,
+  0x87, 0x52, 0x98, 0x2e, 0xcc, 0xb7, 0xa1, 0x6f, 0x88, 0x0f, 0xb5, 0x6f,
+  0xe1, 0x6f, 0x02, 0x30, 0x00, 0x30, 0x1a, 0x2f, 0x44, 0x6f, 0x00, 0x2e,
+  0x00, 0x41, 0x00, 0xb2, 0x0f, 0x2f, 0x64, 0x6f, 0x10, 0x6f, 0x04, 0x41,
+  0x84, 0x0e, 0x00, 0x30, 0x0f, 0x2f, 0x54, 0x6f, 0x20, 0x6f, 0x04, 0x41,
+  0x84, 0x0f, 0x00, 0x30, 0x09, 0x2f, 0x94, 0x6f, 0x10, 0x30, 0x07, 0x2c,
+  0x02, 0x43, 0x08, 0x87, 0xb9, 0x50, 0xd0, 0x42, 0x10, 0x30, 0x00, 0x43,
+  0xc2, 0x42, 0x0b, 0x30, 0x4b, 0x43, 0x7a, 0x8b, 0xc4, 0x6f, 0x06, 0x89,
+  0x52, 0x43, 0x52, 0x43, 0x6c, 0x0e, 0xfb, 0x2f, 0x78, 0x85, 0x00, 0x2e,
+  0x82, 0x40, 0x02, 0x1a, 0x02, 0x2f, 0x00, 0x2e, 0x02, 0x2c, 0x40, 0x42,
+  0x00, 0x30, 0x00, 0x2e, 0xdb, 0x6f, 0xd0, 0x5e, 0xb8, 0x2e, 0x08, 0x82,
+  0x02, 0x30, 0x12, 0x42, 0x08, 0x86, 0xc2, 0x88, 0x87, 0x5a, 0x12, 0x43,
+  0x05, 0x43, 0x02, 0x8b, 0x7c, 0x8d, 0x42, 0x43, 0x14, 0x30, 0xbe, 0x8b,
+  0x04, 0x42, 0x45, 0x81, 0x42, 0x43, 0x02, 0x42, 0x35, 0x80, 0xb9, 0x5e,
+  0xa5, 0x5a, 0xc7, 0x42, 0x84, 0x43, 0x52, 0x43, 0x12, 0x42, 0x52, 0x43,
+  0x12, 0x42, 0x52, 0x43, 0x52, 0x43, 0x41, 0x0e, 0xf7, 0x2f, 0xb8, 0x2e,
+  0x0a, 0x0c, 0x55, 0x56, 0x03, 0x09, 0x0a, 0x04, 0x00, 0xb3, 0x07, 0x2f,
+  0x88, 0x0c, 0x93, 0x08, 0x80, 0xb2, 0x03, 0x2f, 0x53, 0x50, 0xc0, 0x2e,
+  0x40, 0xac, 0x03, 0x22, 0xb8, 0x2e, 0xff, 0x88, 0x10, 0x30, 0x4a, 0x0d,
+  0x0a, 0x18, 0x04, 0x15, 0x4c, 0x16, 0x5f, 0xb9, 0x79, 0x08, 0x53, 0x5a,
+  0x95, 0x00, 0x34, 0x09, 0x40, 0x90, 0x02, 0x2f, 0x00, 0x91, 0x00, 0x2f,
+  0x00, 0x30, 0xd8, 0x00, 0xc0, 0xb2, 0x0b, 0x2f, 0xd0, 0xa0, 0x03, 0x2f,
+  0xf0, 0x86, 0xbb, 0x11, 0x07, 0x2c, 0xce, 0x17, 0x01, 0x31, 0x4b, 0x04,
+  0x79, 0x14, 0x33, 0x12, 0xfb, 0x11, 0x81, 0x0b, 0xce, 0x16, 0xc0, 0x2e,
+  0x7b, 0x1a, 0x16, 0x22, 0x80, 0x2e, 0x18, 0x00, 0x80, 0x2e, 0x18, 0x00,
+  0x80, 0x2e, 0x18, 0x00, 0x80, 0x2e, 0x18, 0x00, 0x80, 0x2e, 0x18, 0x00,
+  0x80, 0x2e, 0x18, 0x00, 0x80, 0x2e, 0x18, 0x00, 0x80, 0x2e, 0x18, 0x00,
+  0x80, 0x2e, 0x18, 0x00, 0x80, 0x2e, 0x18, 0x00, 0x80, 0x2e, 0x18, 0x00,
+  0x80, 0x2e, 0x18, 0x00, 0x80, 0x2e, 0x18, 0x00, 0x80, 0x2e, 0x18, 0x00,
+  0x80, 0x2e, 0x18, 0x00, 0x80, 0x2e, 0x18, 0x00, 0x80, 0x2e, 0x18, 0x00,
+  0x80, 0x2e, 0x18, 0x00, 0x80, 0x2e, 0x18, 0x00, 0x80, 0x2e, 0x18, 0x00,
+  0x80, 0x2e, 0x18, 0x00, 0x80, 0x2e, 0x18, 0x00, 0x80, 0x2e, 0x18, 0x00,
+  0x80, 0x2e, 0x18, 0x00, 0x80, 0x2e, 0x18, 0x00, 0x80, 0x2e, 0x18, 0x00,
+  0x80, 0x2e, 0x18, 0x00, 0x80, 0x2e, 0x18, 0x00, 0x80, 0x2e, 0x18, 0x00,
+  0x80, 0x2e, 0x18, 0x00, 0x80, 0x2e, 0x18, 0x00, 0x80, 0x2e, 0x18, 0x00,
+  0x80, 0x2e, 0x18, 0x00, 0x80, 0x2e, 0x18, 0x00, 0x80, 0x2e, 0x18, 0x00,
+  0x80, 0x2e, 0x18, 0x00, 0x80, 0x2e, 0x18, 0x00, 0x80, 0x2e, 0x18, 0x00,
+  0x80, 0x2e, 0x18, 0x00, 0x80, 0x2e, 0x18, 0x00, 0x80, 0x2e, 0x18, 0x00,
+  0x80, 0x2e, 0x18, 0x00, 0x80, 0x2e, 0x18, 0x00, 0x80, 0x2e, 0x18, 0x00,
+  0x80, 0x2e, 0x18, 0x00, 0x80, 0x2e, 0x18, 0x00, 0x80, 0x2e, 0x18, 0x00,
+  0x80, 0x2e, 0x18, 0x00, 0x80, 0x2e, 0x18, 0x00, 0x80, 0x2e, 0x18, 0x00,
+  0x80, 0x2e, 0x18, 0x00, 0x80, 0x2e, 0x18, 0x00, 0x80, 0x2e, 0x18, 0x00,
+  0x80, 0x2e, 0x18, 0x00, 0x80, 0x2e, 0x18, 0x00, 0x80, 0x2e, 0x18, 0x00,
+  0x80, 0x2e, 0x18, 0x00, 0x80, 0x2e, 0x18, 0x00, 0x80, 0x2e, 0x18, 0x00,
+  0x80, 0x2e, 0x18, 0x00, 0x80, 0x2e, 0x18, 0x00, 0x80, 0x2e, 0x18, 0x00,
+  0x80, 0x2e, 0x18, 0x00, 0x80, 0x2e, 0x18, 0x00, 0x80, 0x2e, 0x18, 0x00,
+  0x80, 0x2e, 0x18, 0x00, 0x80, 0x2e, 0x18, 0x00, 0x80, 0x2e, 0x18, 0x00,
+  0x80, 0x2e, 0x18, 0x00, 0x80, 0x2e, 0x18, 0x00, 0x80, 0x2e, 0x18, 0x00,
+  0x80, 0x2e, 0x18, 0x00, 0x80, 0x2e, 0x18, 0x00, 0x80, 0x2e, 0x18, 0x00,
+  0x80, 0x2e, 0x18, 0x00, 0x80, 0x2e, 0x18, 0x00, 0x80, 0x2e, 0x18, 0x00,
+  0x80, 0x2e, 0x18, 0x00, 0x80, 0x2e, 0x18, 0x00, 0x80, 0x2e, 0x18, 0x00,
+  0x80, 0x2e, 0x18, 0x00, 0x80, 0x2e, 0x18, 0x00, 0x80, 0x2e, 0x18, 0x00,
+  0x80, 0x2e, 0x18, 0x00, 0x80, 0x2e, 0x18, 0x00, 0x80, 0x2e, 0x18, 0x00,
+  0x80, 0x2e, 0x18, 0x00, 0x80, 0x2e, 0x18, 0x00, 0x80, 0x2e, 0x18, 0x00,
+  0x80, 0x2e, 0x18, 0x00, 0x80, 0x2e, 0x18, 0x00, 0x80, 0x2e, 0x18, 0x00,
+  0x80, 0x2e, 0x18, 0x00, 0x80, 0x2e, 0x18, 0x00, 0x80, 0x2e, 0x18, 0x00,
+  0x80, 0x2e, 0x18, 0x00, 0x80, 0x2e, 0x18, 0x00, 0x80, 0x2e, 0x18, 0x00,
+  0x80, 0x2e, 0x18, 0x00, 0x80, 0x2e, 0x18, 0x00, 0x80, 0x2e, 0x18, 0x00,
+  0x80, 0x2e, 0x18, 0x00, 0x80, 0x2e, 0x18, 0x00, 0x80, 0x2e, 0x18, 0x00,
+  0x80, 0x2e, 0x18, 0x00, 0x80, 0x2e, 0x18, 0x00, 0x80, 0x2e, 0x18, 0x00,
+  0x80, 0x2e, 0x18, 0x00, 0x80, 0x2e, 0x18, 0x00, 0x80, 0x2e, 0x18, 0x00,
+  0x80, 0x2e, 0x18, 0x00, 0x80, 0x2e, 0x18, 0x00, 0x80, 0x2e, 0x18, 0x00,
+  0x80, 0x2e, 0x18, 0x00, 0x80, 0x2e, 0x18, 0x00, 0x80, 0x2e, 0x18, 0x00,
+  0x80, 0x2e, 0x18, 0x00, 0x80, 0x2e, 0x18, 0x00, 0x80, 0x2e, 0x18, 0x00,
+  0x80, 0x2e, 0x18, 0x00, 0x80, 0x2e, 0x18, 0x00, 0x80, 0x2e, 0x18, 0x00,
+  0x80, 0x2e, 0x18, 0x00, 0x80, 0x2e, 0x18, 0x00, 0x80, 0x2e, 0x18, 0x00,
+  0x80, 0x2e, 0x18, 0x00, 0x80, 0x2e, 0x18, 0x00, 0x80, 0x2e, 0x18, 0x00,
+  0x80, 0x2e, 0x18, 0x00, 0x80, 0x2e, 0x18, 0x00, 0x80, 0x2e, 0x18, 0x00,
+  0x80, 0x2e, 0x18, 0x00, 0x80, 0x2e, 0x18, 0x00, 0x80, 0x2e, 0x18, 0x00,
+  0x80, 0x2e, 0x18, 0x00, 0x80, 0x2e, 0x18, 0x00, 0x80, 0x2e, 0x18, 0x00,
+  0x80, 0x2e, 0x18, 0x00, 0x80, 0x2e, 0x18, 0x00, 0x80, 0x2e, 0x18, 0x00,
+  0x80, 0x2e, 0x18, 0x00, 0x80, 0x2e, 0x18, 0x00, 0x80, 0x2e, 0x18, 0x00,
+  0x80, 0x2e, 0x18, 0x00, 0x80, 0x2e, 0x18, 0x00, 0x80, 0x2e, 0x18, 0x00,
+  0x80, 0x2e, 0x18, 0x00, 0x80, 0x2e, 0x18, 0x00, 0x80, 0x2e, 0x18, 0x00,
+  0x80, 0x2e, 0x18, 0x00, 0x80, 0x2e, 0x18, 0x00, 0x80, 0x2e, 0x18, 0x00,
+  0x80, 0x2e, 0x18, 0x00, 0x80, 0x2e, 0x18, 0x00, 0x80, 0x2e, 0x18, 0x00,
+  0x80, 0x2e, 0x18, 0x00, 0x80, 0x2e, 0x18, 0x00, 0x80, 0x2e, 0x18, 0x00,
+  0x80, 0x2e, 0x18, 0x00, 0x80, 0x2e, 0x18, 0x00, 0x80, 0x2e, 0x18, 0x00,
+  0x80, 0x2e, 0x18, 0x00, 0x80, 0x2e, 0x18, 0x00, 0x80, 0x2e, 0x18, 0x00,
+  0x80, 0x2e, 0x18, 0x00, 0x80, 0x2e, 0x18, 0x00, 0x80, 0x2e, 0x18, 0x00,
+  0x80, 0x2e, 0x18, 0x00, 0x80, 0x2e, 0x18, 0x00, 0x80, 0x2e, 0x18, 0x00,
+  0x80, 0x2e, 0x18, 0x00, 0x80, 0x2e, 0x18, 0x00, 0x80, 0x2e, 0x18, 0x00,
+  0x80, 0x2e, 0x18, 0x00, 0x80, 0x2e, 0x18, 0x00, 0x80, 0x2e, 0x18, 0x00,
+  0x80, 0x2e, 0x18, 0x00, 0x80, 0x2e, 0x18, 0x00, 0x80, 0x2e, 0x18, 0x00,
+  0x80, 0x2e, 0x18, 0x00, 0x80, 0x2e, 0x18, 0x00, 0x80, 0x2e, 0x18, 0x00,
+  0x80, 0x2e, 0x18, 0x00, 0x80, 0x2e, 0x18, 0x00, 0x80, 0x2e, 0x18, 0x00,
+  0x80, 0x2e, 0x18, 0x00, 0x80, 0x2e, 0x18, 0x00, 0x80, 0x2e, 0x18, 0x00,
+  0x80, 0x2e, 0x18, 0x00, 0x80, 0x2e, 0x18, 0x00, 0x80, 0x2e, 0x18, 0x00,
+  0x80, 0x2e, 0x18, 0x00, 0x80, 0x2e, 0x18, 0x00, 0x80, 0x2e, 0x18, 0x00,
+  0x80, 0x2e, 0x18, 0x00, 0x80, 0x2e, 0x18, 0x00, 0x80, 0x2e, 0x18, 0x00,
+  0x80, 0x2e, 0x18, 0x00, 0x80, 0x2e, 0x18, 0x00, 0x80, 0x2e, 0x18, 0x00,
+  0x80, 0x2e, 0x18, 0x00, 0x80, 0x2e, 0x18, 0x00, 0x80, 0x2e, 0x18, 0x00,
+  0x80, 0x2e, 0x18, 0x00, 0x80, 0x2e, 0x18, 0x00, 0x80, 0x2e, 0x18, 0x00,
+  0x80, 0x2e, 0x18, 0x00, 0x80, 0x2e, 0x18, 0x00, 0x80, 0x2e, 0x18, 0x00,
+  0x80, 0x2e, 0x18, 0x00, 0x80, 0x2e, 0x18, 0x00, 0x80, 0x2e, 0x18, 0x00,
+  0x80, 0x2e, 0x18, 0x00, 0x80, 0x2e, 0x18, 0x00, 0x80, 0x2e, 0x18, 0x00,
+  0x80, 0x2e, 0x18, 0x00, 0x80, 0x2e, 0x18, 0x00, 0x80, 0x2e, 0x18, 0x00,
+  0x80, 0x2e, 0x18, 0x00, 0x80, 0x2e, 0x18, 0x00, 0x80, 0x2e, 0x18, 0x00,
+  0x80, 0x2e, 0x18, 0x00, 0x80, 0x2e, 0x18, 0x00, 0x80, 0x2e, 0x18, 0x00,
+  0x80, 0x2e, 0x18, 0x00, 0x80, 0x2e, 0x18, 0x00, 0x80, 0x2e, 0x18, 0x00,
+  0x80, 0x2e, 0x18, 0x00, 0x80, 0x2e, 0x18, 0x00, 0x80, 0x2e, 0x18, 0x00,
+  0x80, 0x2e, 0x18, 0x00, 0x80, 0x2e, 0x18, 0x00, 0x80, 0x2e, 0x18, 0x00,
+  0x80, 0x2e, 0x18, 0x00, 0x80, 0x2e, 0x18, 0x00, 0x80, 0x2e, 0x18, 0x00,
+  0x80, 0x2e, 0x18, 0x00, 0x80, 0x2e, 0x18, 0x00, 0x80, 0x2e, 0x18, 0x00,
+  0x80, 0x2e, 0x18, 0x00, 0x80, 0x2e, 0x18, 0x00, 0x80, 0x2e, 0x18, 0x00,
+  0x80, 0x2e, 0x18, 0x00, 0x80, 0x2e, 0x18, 0x00, 0x80, 0x2e, 0x18, 0x00,
+  0x80, 0x2e, 0x18, 0x00, 0x80, 0x2e, 0x18, 0x00, 0x80, 0x2e, 0x18, 0x00,
+  0x80, 0x2e, 0x18, 0x00, 0x80, 0x2e, 0x18, 0x00, 0x80, 0x2e, 0x18, 0x00,
+  0x80, 0x2e, 0x18, 0x00, 0x80, 0x2e, 0x18, 0x00, 0x80, 0x2e, 0x18, 0x00,
+  0x80, 0x2e, 0x18, 0x00, 0x80, 0x2e, 0x18, 0x00, 0x80, 0x2e, 0x18, 0x00
+};
+
 const uint8_t bma423_config_file[] = {
   0x80, 0x2e, 0xfe, 0x00, 0x80, 0x2e, 0xf1, 0x01, 0xc8, 0x2e, 0x00, 0x2e, 0x80, 0x2e, 0xfc, 0x00, 0x80, 0x2e, 0xfb,
   0x00, 0x80, 0x2e, 0xff, 0x00, 0x80, 0x2e, 0xfd, 0x00, 0x80, 0x2e, 0x42, 0xb0, 0x50, 0x39, 0x21, 0x2e, 0xb0, 0xf0,
@@ -450,7 +965,7 @@ int8_t bma423_init(struct bma4_dev *dev)
     rslt = bma4_init(dev);
     if (rslt == BMA4_OK)
     {
-        if (dev->chip_id == BMA423_CHIP_ID)
+        if (dev->chip_id == BMA423_CHIP_ID || dev->chip_id == BMA425_CHIP_ID)
         {
             /* Resolution of BMA423 sensor is 12 bit */
             dev->resolution = 12;
@@ -478,7 +993,7 @@ int8_t bma423_write_config_file(struct bma4_dev *dev)
 
     if (dev != NULL)
     {
-        if (dev->chip_id == BMA423_CHIP_ID)
+        if (dev->chip_id == BMA423_CHIP_ID || dev->chip_id == BMA425_CHIP_ID)
         {
             /* Configuration stream read/write length boundary
              * check
@@ -492,7 +1007,10 @@ int8_t bma423_write_config_file(struct bma4_dev *dev)
                 }
 
                 /*Assign stream data */
-                dev->config_file_ptr = bma423_config_file;
+                if(dev->chip_id == BMA423_CHIP_ID)
+                  dev->config_file_ptr = bma423_config_file;
+                else if(dev->chip_id == BMA425_CHIP_ID)
+                  dev->config_file_ptr = bma425_config_file;
                 rslt = bma4_write_config_file(dev);
             }
             else
@@ -526,7 +1044,7 @@ int8_t bma423_get_config_id(uint16_t *config_id, struct bma4_dev *dev)
 
     if (dev != NULL)
     {
-        if (dev->chip_id == BMA423_CHIP_ID)
+        if (dev->chip_id == BMA423_CHIP_ID || dev->chip_id == BMA425_CHIP_ID)
         {
             rslt = bma4_read_regs(BMA4_FEATURE_CONFIG_ADDR, feature_config, BMA423_FEATURE_SIZE, dev);
             if (rslt == BMA4_OK)
@@ -559,7 +1077,7 @@ int8_t bma423_map_interrupt(uint8_t int_line, uint16_t int_map, uint8_t enable,
 
     if (dev != NULL)
     {
-        if (dev->chip_id == BMA423_CHIP_ID)
+        if (dev->chip_id == BMA423_CHIP_ID || dev->chip_id == BMA425_CHIP_ID)
         {
             if (int_line <= 1)
             {
@@ -593,7 +1111,7 @@ int8_t bma423_read_int_status(uint16_t *int_status, struct bma4_dev *dev)
 
     if (dev != NULL)
     {
-        if (dev->chip_id == BMA423_CHIP_ID)
+        if (dev->chip_id == BMA423_CHIP_ID || dev->chip_id == BMA425_CHIP_ID)
         {
             /* Read the interrupt status */
             rslt = bma4_read_int_status(int_status, dev);
@@ -622,7 +1140,7 @@ int8_t bma423_feature_enable(uint8_t feature, uint8_t enable, struct bma4_dev *d
 
     if (dev != NULL)
     {
-        if (dev->chip_id == BMA423_CHIP_ID)
+        if (dev->chip_id == BMA423_CHIP_ID || dev->chip_id == BMA425_CHIP_ID)
         {
             /* Read feature configuration data */
             rslt = bma4_read_regs(BMA4_FEATURE_CONFIG_ADDR, feature_config, len, dev);
@@ -669,7 +1187,7 @@ int8_t bma423_set_remap_axes(const struct bma423_axes_remap *remap_data, struct
 
     if (dev != NULL)
     {
-        if (dev->chip_id == BMA423_CHIP_ID)
+        if (dev->chip_id == BMA423_CHIP_ID || dev->chip_id == BMA425_CHIP_ID)
         {
             rslt = bma4_read_regs(BMA4_FEATURE_CONFIG_ADDR, feature_config, BMA423_FEATURE_SIZE, dev);
             if (rslt == BMA4_OK)
@@ -708,7 +1226,7 @@ int8_t bma423_get_remap_axes(struct bma423_axes_remap *remap_data, struct bma4_d
 
     if (dev != NULL)
     {
-        if (dev->chip_id == BMA423_CHIP_ID)
+        if (dev->chip_id == BMA423_CHIP_ID || dev->chip_id == BMA425_CHIP_ID)
         {
             rslt = bma4_read_regs(BMA4_FEATURE_CONFIG_ADDR, feature_config, BMA423_FEATURE_SIZE, dev);
             if (rslt == BMA4_OK)
@@ -997,7 +1515,7 @@ int8_t bma423_step_detector_enable(uint8_t enable, struct bma4_dev *dev)
 
     if (dev != NULL)
     {
-        if (dev->chip_id == BMA423_CHIP_ID)
+        if (dev->chip_id == BMA423_CHIP_ID || dev->chip_id == BMA425_CHIP_ID)
         {
             rslt = bma4_read_regs(BMA4_FEATURE_CONFIG_ADDR, feature_config, BMA423_FEATURE_SIZE, dev);
             if (rslt == BMA4_OK)
@@ -1034,7 +1552,7 @@ int8_t bma423_step_counter_set_watermark(uint16_t step_counter_wm, struct bma4_d
 
     if (dev != NULL)
     {
-        if (dev->chip_id == BMA423_CHIP_ID)
+        if (dev->chip_id == BMA423_CHIP_ID || dev->chip_id == BMA425_CHIP_ID)
         {
             rslt = bma4_read_regs(BMA4_FEATURE_CONFIG_ADDR, feature_config, BMA423_FEATURE_SIZE, dev);
             if (rslt == BMA4_OK)
@@ -1088,7 +1606,7 @@ int8_t bma423_step_counter_get_watermark(uint16_t *step_counter_wm, struct bma4_
 
     if (dev != NULL)
     {
-        if (dev->chip_id == BMA423_CHIP_ID)
+        if (dev->chip_id == BMA423_CHIP_ID || dev->chip_id == BMA425_CHIP_ID)
         {
             rslt = bma4_read_regs(BMA4_FEATURE_CONFIG_ADDR, feature_config, BMA423_FEATURE_SIZE, dev);
             if (rslt == BMA4_OK)
@@ -1125,7 +1643,7 @@ int8_t bma423_reset_step_counter(struct bma4_dev *dev)
 
     if (dev != NULL)
     {
-        if (dev->chip_id == BMA423_CHIP_ID)
+        if (dev->chip_id == BMA423_CHIP_ID || dev->chip_id == BMA425_CHIP_ID)
         {
             rslt = bma4_read_regs(BMA4_FEATURE_CONFIG_ADDR, feature_config, BMA423_FEATURE_SIZE, dev);
             if (rslt == BMA4_OK)
@@ -1162,7 +1680,7 @@ int8_t bma423_step_counter_output(uint32_t *step_count, struct bma4_dev *dev)
 
     if (dev != NULL)
     {
-        if (dev->chip_id == BMA423_CHIP_ID)
+        if (dev->chip_id == BMA423_CHIP_ID || dev->chip_id == BMA425_CHIP_ID)
         {
             /* Reads the step counter output data from the
              * gpio register
@@ -1200,7 +1718,7 @@ int8_t bma423_activity_output(uint8_t *activity, struct bma4_dev *dev)
 
     if (dev != NULL)
     {
-        if (dev->chip_id == BMA423_CHIP_ID)
+        if (dev->chip_id == BMA423_CHIP_ID || dev->chip_id == BMA425_CHIP_ID)
         {
             /* Reads the activity output from the gpio register */
             rslt = bma4_read_regs(BMA4_ACTIVITY_OUT_ADDR, &data, 1, dev);
@@ -1234,7 +1752,7 @@ int8_t bma423_stepcounter_get_parameter(struct bma423_stepcounter_settings *sett
 
     if (dev != NULL)
     {
-        if (dev->chip_id == BMA423_CHIP_ID)
+        if (dev->chip_id == BMA423_CHIP_ID || dev->chip_id == BMA425_CHIP_ID)
         {
             rslt = bma4_read_regs(BMA4_FEATURE_CONFIG_ADDR, feature_config, BMA423_FEATURE_SIZE, dev);
             if (rslt == BMA4_OK)
@@ -1269,7 +1787,7 @@ int8_t bma423_stepcounter_set_parameter(const struct bma423_stepcounter_settings
 
     if (dev != NULL)
     {
-        if (dev->chip_id == BMA423_CHIP_ID)
+        if (dev->chip_id == BMA423_CHIP_ID || dev->chip_id == BMA425_CHIP_ID)
         {
             rslt = bma4_read_regs(BMA4_FEATURE_CONFIG_ADDR, feature_config, BMA423_FEATURE_SIZE, dev);
             if (rslt == BMA4_OK)
@@ -1306,7 +1824,7 @@ int8_t bma423_single_tap_set_sensitivity(uint8_t sensitivity, struct bma4_dev *d
 
     if (dev != NULL)
     {
-        if (dev->chip_id == BMA423_CHIP_ID)
+        if (dev->chip_id == BMA423_CHIP_ID || dev->chip_id == BMA425_CHIP_ID)
         {
             rslt = bma4_read_regs(BMA4_FEATURE_CONFIG_ADDR, feature_config, BMA423_FEATURE_SIZE, dev);
             if (rslt == BMA4_OK)
@@ -1341,7 +1859,7 @@ int8_t bma423_double_tap_set_sensitivity(uint8_t sensitivity, struct bma4_dev *d
 
     if (dev != NULL)
     {
-        if (dev->chip_id == BMA423_CHIP_ID)
+        if (dev->chip_id == BMA423_CHIP_ID || dev->chip_id == BMA425_CHIP_ID)
         {
             rslt = bma4_read_regs(BMA4_FEATURE_CONFIG_ADDR, feature_config, BMA423_FEATURE_SIZE, dev);
             if (rslt == BMA4_OK)
@@ -1376,7 +1894,7 @@ int8_t bma423_single_tap_get_sensitivity(uint8_t *sensitivity, struct bma4_dev *
 
     if (dev != NULL)
     {
-        if (dev->chip_id == BMA423_CHIP_ID)
+        if (dev->chip_id == BMA423_CHIP_ID || dev->chip_id == BMA425_CHIP_ID)
         {
             rslt = bma4_read_regs(BMA4_FEATURE_CONFIG_ADDR, feature_config, BMA423_FEATURE_SIZE, dev);
             if (rslt == BMA4_OK)
@@ -1409,7 +1927,7 @@ int8_t bma423_double_tap_get_sensitivity(uint8_t *sensitivity, struct bma4_dev *
 
     if (dev != NULL)
     {
-        if (dev->chip_id == BMA423_CHIP_ID)
+        if (dev->chip_id == BMA423_CHIP_ID || dev->chip_id == BMA425_CHIP_ID)
         {
             rslt = bma4_read_regs(BMA4_FEATURE_CONFIG_ADDR, feature_config, BMA423_FEATURE_SIZE, dev);
             if (rslt == BMA4_OK)
diff --git a/src/drivers/Bma421_C/bma423.h b/src/drivers/Bma421_C/bma423.h
index 96e5d8e3..b58e0d21 100644
--- a/src/drivers/Bma421_C/bma423.h
+++ b/src/drivers/Bma421_C/bma423.h
@@ -52,6 +52,7 @@ extern "C" {
 
 /**\name Chip ID of BMA423 sensor */
 #define BMA423_CHIP_ID                 UINT8_C(0x11)
+#define BMA425_CHIP_ID                 UINT8_C(0x13)
 
 /**\ Configuration ID start position of BMA423 sensor */
 #define BMA423_CONFIG_ID_START_ADDR    UINT8_C(66)
diff --git a/src/systemtask/SystemTask.cpp b/src/systemtask/SystemTask.cpp
index 38e9793c..13755f71 100644
--- a/src/systemtask/SystemTask.cpp
+++ b/src/systemtask/SystemTask.cpp
@@ -126,6 +126,7 @@ void SystemTask::Work() {
   twiMaster.Init();
 
   motionSensor.Init();
+  motionController.Init(motionSensor.DeviceType());
   settingsController.Init();
 
   displayApp.Register(this);
-- 
cgit v1.2.3-70-g09d2


From 084123b752c74f7b8a6da23cb9bce0ac4efa3715 Mon Sep 17 00:00:00 2001
From: "joaquim.org" <joaquim.org@gmail.com>
Date: Sun, 11 Jul 2021 14:06:06 +0100
Subject: Using littlefs (#438)

* add submodule littlefs
* base fs
* Save settings using littlefs
* Small fixes and suggestions from PR
* More small fixes from PR suggestions
* Code clean up
* Change SpiNorFlash functions to be private in FS
---
 .gitmodules                          |   3 +
 src/CMakeLists.txt                   |  29 +++++-
 src/components/fs/FS.cpp             | 197 +++++++++++++++++++++++++++++++++++
 src/components/fs/FS.h               |  71 +++++++++++++
 src/components/settings/Settings.cpp | 100 ++++--------------
 src/components/settings/Settings.h   |  58 +++++------
 src/libs/littlefs                    |   1 +
 src/libs/lv_conf.h                   |   4 +-
 src/main.cpp                         |  13 ++-
 src/systemtask/SystemTask.cpp        |  11 +-
 src/systemtask/SystemTask.h          |  12 ++-
 11 files changed, 369 insertions(+), 130 deletions(-)
 create mode 100644 src/components/fs/FS.cpp
 create mode 100644 src/components/fs/FS.h
 create mode 160000 src/libs/littlefs

(limited to 'src/systemtask/SystemTask.cpp')

diff --git a/.gitmodules b/.gitmodules
index 6f6d0e10..815fc022 100644
--- a/.gitmodules
+++ b/.gitmodules
@@ -1,3 +1,6 @@
 [submodule "src/libs/lvgl"]
 	path = src/libs/lvgl
 	url = https://github.com/joaquimorg/lvgl.git
+[submodule "src/libs/littlefs"]
+	path = src/libs/littlefs
+	url = https://github.com/littlefs-project/littlefs.git
diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt
index aca86543..40e1f2a5 100644
--- a/src/CMakeLists.txt
+++ b/src/CMakeLists.txt
@@ -166,6 +166,13 @@ set(NIMBLE_SRC
         libs/mynewt-nimble/nimble/host/util/src/addr.c
         )
 
+set(LITTLEFS_SRC
+        libs/littlefs/lfs_util.h
+        libs/littlefs/lfs.h
+        libs/littlefs/lfs_util.c
+        libs/littlefs/lfs.c
+        )
+
 set(LVGL_SRC
         libs/lv_conf.h
         libs/lvgl/lvgl.h
@@ -465,6 +472,7 @@ list(APPEND SOURCE_FILES
         components/motor/MotorController.cpp
         components/settings/Settings.cpp
         components/timer/TimerController.cpp
+        components/fs/FS.cpp
         drivers/Cst816s.cpp
         FreeRTOS/port.c
         FreeRTOS/port_cmsis_systick.c
@@ -543,6 +551,7 @@ list(APPEND RECOVERY_SOURCE_FILES
         components/heartrate/Biquad.cpp
         components/heartrate/Ptagc.cpp
         components/motor/MotorController.cpp
+        components/fs/FS.cpp
         )
 
 list(APPEND RECOVERYLOADER_SOURCE_FILES
@@ -801,13 +810,25 @@ target_compile_options(lvgl PRIVATE
         $<$<COMPILE_LANGUAGE:ASM>: -MP -MD -x assembler-with-cpp>
         )
 
+# LITTLEFS_SRC
+add_library(littlefs STATIC ${LITTLEFS_SRC})
+target_include_directories(littlefs SYSTEM PUBLIC . ../)
+target_include_directories(littlefs SYSTEM PUBLIC ${INCLUDES_FROM_LIBS})
+target_compile_options(littlefs PRIVATE
+        $<$<AND:$<COMPILE_LANGUAGE:C>,$<CONFIG:DEBUG>>: ${COMMON_FLAGS} -Wno-unused-function -Og -g3>
+        $<$<AND:$<COMPILE_LANGUAGE:C>,$<CONFIG:RELEASE>>: ${COMMON_FLAGS} -Wno-unused-function -Os>
+        $<$<AND:$<COMPILE_LANGUAGE:CXX>,$<CONFIG:DEBUG>>: ${COMMON_FLAGS} -Wno-unused-function -Og -g3 -fno-rtti>
+        $<$<AND:$<COMPILE_LANGUAGE:CXX>,$<CONFIG:RELEASE>>: ${COMMON_FLAGS} -Wno-unused-function -Os -fno-rtti>
+        $<$<COMPILE_LANGUAGE:ASM>: -MP -MD -x assembler-with-cpp>
+        )
+
 # Build autonomous binary (without support for bootloader)
 set(EXECUTABLE_NAME "pinetime-app")
 set(EXECUTABLE_FILE_NAME ${EXECUTABLE_NAME}-${pinetime_VERSION_MAJOR}.${pinetime_VERSION_MINOR}.${pinetime_VERSION_PATCH})
 set(NRF5_LINKER_SCRIPT "${CMAKE_SOURCE_DIR}/gcc_nrf52.ld")
 add_executable(${EXECUTABLE_NAME} ${SOURCE_FILES})
 set_target_properties(${EXECUTABLE_NAME} PROPERTIES OUTPUT_NAME ${EXECUTABLE_FILE_NAME})
-target_link_libraries(${EXECUTABLE_NAME} nimble nrf-sdk lvgl)
+target_link_libraries(${EXECUTABLE_NAME} nimble nrf-sdk lvgl littlefs)
 target_compile_options(${EXECUTABLE_NAME} PUBLIC
         $<$<AND:$<COMPILE_LANGUAGE:C>,$<CONFIG:DEBUG>>: ${COMMON_FLAGS} -Og -g3>
         $<$<AND:$<COMPILE_LANGUAGE:C>,$<CONFIG:RELEASE>>: ${COMMON_FLAGS} -Os>
@@ -836,7 +857,7 @@ set(IMAGE_MCUBOOT_FILE_NAME ${EXECUTABLE_MCUBOOT_NAME}-image-${pinetime_VERSION_
 set(DFU_MCUBOOT_FILE_NAME ${EXECUTABLE_MCUBOOT_NAME}-dfu-${pinetime_VERSION_MAJOR}.${pinetime_VERSION_MINOR}.${pinetime_VERSION_PATCH}.zip)
 set(NRF5_LINKER_SCRIPT_MCUBOOT "${CMAKE_SOURCE_DIR}/gcc_nrf52-mcuboot.ld")
 add_executable(${EXECUTABLE_MCUBOOT_NAME} ${SOURCE_FILES})
-target_link_libraries(${EXECUTABLE_MCUBOOT_NAME} nimble nrf-sdk lvgl)
+target_link_libraries(${EXECUTABLE_MCUBOOT_NAME} nimble nrf-sdk lvgl littlefs)
 set_target_properties(${EXECUTABLE_MCUBOOT_NAME} PROPERTIES OUTPUT_NAME ${EXECUTABLE_MCUBOOT_FILE_NAME})
 target_compile_options(${EXECUTABLE_MCUBOOT_NAME} PUBLIC
         $<$<AND:$<COMPILE_LANGUAGE:C>,$<CONFIG:DEBUG>>: ${COMMON_FLAGS} -Og -g3>
@@ -872,7 +893,7 @@ endif()
 set(EXECUTABLE_RECOVERY_NAME "pinetime-recovery")
 set(EXECUTABLE_RECOVERY_FILE_NAME ${EXECUTABLE_RECOVERY_NAME}-${pinetime_VERSION_MAJOR}.${pinetime_VERSION_MINOR}.${pinetime_VERSION_PATCH})
 add_executable(${EXECUTABLE_RECOVERY_NAME} ${RECOVERY_SOURCE_FILES})
-target_link_libraries(${EXECUTABLE_RECOVERY_NAME} nimble nrf-sdk)
+target_link_libraries(${EXECUTABLE_RECOVERY_NAME} nimble nrf-sdk littlefs)
 set_target_properties(${EXECUTABLE_RECOVERY_NAME} PROPERTIES OUTPUT_NAME ${EXECUTABLE_RECOVERY_FILE_NAME})
 target_compile_definitions(${EXECUTABLE_RECOVERY_NAME} PUBLIC "PINETIME_IS_RECOVERY")
 target_compile_options(${EXECUTABLE_RECOVERY_NAME} PUBLIC
@@ -902,7 +923,7 @@ set(EXECUTABLE_RECOVERY_MCUBOOT_FILE_NAME ${EXECUTABLE_RECOVERY_MCUBOOT_NAME}-${
 set(IMAGE_RECOVERY_MCUBOOT_FILE_NAME ${EXECUTABLE_RECOVERY_MCUBOOT_NAME}-image-${pinetime_VERSION_MAJOR}.${pinetime_VERSION_MINOR}.${pinetime_VERSION_PATCH}.bin)
 set(DFU_RECOVERY_MCUBOOT_FILE_NAME ${EXECUTABLE_RECOVERY_MCUBOOT_NAME}-dfu-${pinetime_VERSION_MAJOR}.${pinetime_VERSION_MINOR}.${pinetime_VERSION_PATCH}.zip)
 add_executable(${EXECUTABLE_RECOVERY_MCUBOOT_NAME} ${RECOVERY_SOURCE_FILES})
-target_link_libraries(${EXECUTABLE_RECOVERY_MCUBOOT_NAME} nimble nrf-sdk)
+target_link_libraries(${EXECUTABLE_RECOVERY_MCUBOOT_NAME} nimble nrf-sdk littlefs)
 set_target_properties(${EXECUTABLE_RECOVERY_MCUBOOT_NAME} PROPERTIES OUTPUT_NAME ${EXECUTABLE_RECOVERY_MCUBOOT_FILE_NAME})
 target_compile_definitions(${EXECUTABLE_RECOVERY_MCUBOOT_NAME} PUBLIC "PINETIME_IS_RECOVERY")
 target_compile_options(${EXECUTABLE_RECOVERY_MCUBOOT_NAME} PUBLIC
diff --git a/src/components/fs/FS.cpp b/src/components/fs/FS.cpp
new file mode 100644
index 00000000..857e6bf9
--- /dev/null
+++ b/src/components/fs/FS.cpp
@@ -0,0 +1,197 @@
+#include "FS.h"
+#include <cstring>
+#include <littlefs/lfs.h>
+#include <lvgl/lvgl.h>
+
+using namespace Pinetime::Controllers;
+
+FS::FS(Pinetime::Drivers::SpiNorFlash& driver) :
+  flashDriver{ driver },
+  lfsConfig{
+    .context = this,
+    .read = SectorRead,
+    .prog = SectorProg,
+    .erase = SectorErase,
+    .sync = SectorSync,
+
+    .read_size = 16,
+    .prog_size = 8,
+    .block_size = blockSize,
+    .block_count = size / blockSize,
+    .block_cycles = 1000u,
+
+    .cache_size = 16,
+    .lookahead_size = 16,
+
+    .name_max = 50,
+    .attr_max = 50,
+  }
+{ }
+
+
+void FS::Init() {
+
+  // try mount
+  int err = lfs_mount(&lfs, &lfsConfig);
+
+  // reformat if we can't mount the filesystem
+  // this should only happen on the first boot
+  if (err != LFS_ERR_OK) {
+    lfs_format(&lfs, &lfsConfig);
+    err = lfs_mount(&lfs, &lfsConfig);
+    if (err != LFS_ERR_OK) {
+      return;
+    }
+  }
+
+#ifndef PINETIME_IS_RECOVERY
+  VerifyResource();
+  LVGLFileSystemInit();
+#endif
+
+}
+
+void FS::VerifyResource() {
+  // validate the resource metadata
+  resourcesValid = true;
+}
+
+int  FS::FileOpen(lfs_file_t* file_p, const char* fileName, const int flags) {
+  return lfs_file_open(&lfs, file_p, fileName, flags);
+}
+
+int FS::FileClose(lfs_file_t* file_p) {
+  return lfs_file_close(&lfs, file_p);
+}
+
+int FS::FileRead(lfs_file_t* file_p, uint8_t* buff, uint32_t size) {
+  return lfs_file_read(&lfs, file_p, buff, size);
+}
+
+int FS::FileWrite(lfs_file_t* file_p, const uint8_t* buff, uint32_t size) {
+  return lfs_file_write(&lfs, file_p, buff, size);
+}
+
+int FS::FileSeek(lfs_file_t* file_p, uint32_t pos) {
+  return lfs_file_seek(&lfs, file_p, pos, LFS_SEEK_SET);
+}
+
+int FS::FileDelete(const char* fileName) {
+  return lfs_remove(&lfs, fileName);
+}
+
+
+int FS::DirCreate(const char* path) {
+  return lfs_mkdir(&lfs, path);
+}
+
+// Delete directory and all files inside
+int FS::DirDelete(const char* path) {
+
+  lfs_dir_t lfs_dir;
+  lfs_info entryInfo;
+
+  int err;
+  err = lfs_dir_open(&lfs, &lfs_dir, path);
+  if (err) {
+    return err;
+  }
+  while (lfs_dir_read(&lfs, &lfs_dir, &entryInfo)) {
+    lfs_remove(&lfs, entryInfo.name);
+  }
+  lfs_dir_close(&lfs, &lfs_dir);
+  return LFS_ERR_OK;
+}
+
+/*
+
+    ----------- Interface between littlefs and SpiNorFlash -----------
+
+*/
+int FS::SectorSync(const struct lfs_config* c) {
+  return 0;
+}
+
+int FS::SectorErase(const struct lfs_config* c, lfs_block_t block) {
+  Pinetime::Controllers::FS& lfs = *(static_cast<Pinetime::Controllers::FS*>(c->context));
+  const size_t address = startAddress + (block * blockSize);
+  lfs.flashDriver.SectorErase(address);
+  return lfs.flashDriver.EraseFailed() ? -1 : 0;
+}
+
+int FS::SectorProg(const struct lfs_config* c, lfs_block_t block, lfs_off_t off, const void* buffer, lfs_size_t size) {
+  Pinetime::Controllers::FS& lfs = *(static_cast<Pinetime::Controllers::FS*>(c->context));
+  const size_t address = startAddress + (block * blockSize) + off;
+  lfs.flashDriver.Write(address, (uint8_t*) buffer, size);
+  return lfs.flashDriver.ProgramFailed() ? -1 : 0;
+}
+
+int FS::SectorRead(const struct lfs_config* c, lfs_block_t block, lfs_off_t off, void* buffer, lfs_size_t size) {
+  Pinetime::Controllers::FS& lfs = *(static_cast<Pinetime::Controllers::FS*>(c->context));
+  const size_t address = startAddress + (block * blockSize) + off;
+  lfs.flashDriver.Read(address, static_cast<uint8_t*>(buffer), size);
+  return 0;
+}
+
+/*
+
+    ----------- LVGL filesystem integration -----------
+
+*/
+
+namespace {
+  lv_fs_res_t lvglOpen(lv_fs_drv_t* drv, void* file_p, const char* path, lv_fs_mode_t mode) {
+
+    lfs_file_t* file = static_cast<lfs_file_t*>(file_p);
+    FS* filesys = static_cast<FS*>(drv->user_data);
+    filesys->FileOpen(file, path, LFS_O_RDONLY);
+
+    if (file->type == 0) {
+      return LV_FS_RES_FS_ERR;
+    }
+    else {
+      return LV_FS_RES_OK;
+    }
+  }
+
+  lv_fs_res_t lvglClose(lv_fs_drv_t* drv, void* file_p) {
+    FS* filesys = static_cast<FS*>(drv->user_data);
+    lfs_file_t* file = static_cast<lfs_file_t*>(file_p);
+    filesys->FileClose(file);
+
+    return LV_FS_RES_OK;
+  }
+
+  lv_fs_res_t lvglRead(lv_fs_drv_t* drv, void* file_p, void* buf, uint32_t btr, uint32_t* br) {
+    FS* filesys = static_cast<FS*>(drv->user_data);
+    lfs_file_t* file = static_cast<lfs_file_t*>(file_p);
+    filesys->FileRead(file, static_cast<uint8_t*>(buf), btr);
+    *br = btr;
+    return LV_FS_RES_OK;
+  }
+
+  lv_fs_res_t lvglSeek(lv_fs_drv_t* drv, void* file_p, uint32_t pos) {
+    FS* filesys = static_cast<FS*>(drv->user_data);
+    lfs_file_t* file = static_cast<lfs_file_t*>(file_p);
+    filesys->FileSeek(file, pos);
+    return LV_FS_RES_OK;
+  }
+}
+
+void FS::LVGLFileSystemInit() {
+
+  lv_fs_drv_t fs_drv;
+  lv_fs_drv_init(&fs_drv);
+
+  fs_drv.file_size = sizeof(lfs_file_t);
+  fs_drv.letter = 'F';
+  fs_drv.open_cb = lvglOpen;
+  fs_drv.close_cb = lvglClose;
+  fs_drv.read_cb = lvglRead;
+  fs_drv.seek_cb = lvglSeek;
+
+  fs_drv.user_data = this;
+
+  lv_fs_drv_register(&fs_drv);
+
+}
\ No newline at end of file
diff --git a/src/components/fs/FS.h b/src/components/fs/FS.h
new file mode 100644
index 00000000..1f2eb7e0
--- /dev/null
+++ b/src/components/fs/FS.h
@@ -0,0 +1,71 @@
+#pragma once
+
+#include <cstdint>
+#include "drivers/SpiNorFlash.h"
+#include <littlefs/lfs.h>
+
+namespace Pinetime {
+  namespace Controllers {
+    class FS {
+    public:
+      FS(Pinetime::Drivers::SpiNorFlash&);
+
+      void Init();
+      void LVGLFileSystemInit();
+
+      int FileOpen(lfs_file_t* file_p, const char* fileName, const int flags);
+      int FileClose(lfs_file_t* file_p);
+      int FileRead(lfs_file_t* file_p, uint8_t* buff, uint32_t size);
+      int FileWrite(lfs_file_t* file_p, const uint8_t* buff, uint32_t size);
+      int FileSeek(lfs_file_t* file_p, uint32_t pos);
+
+      int FileDelete(const char* fileName);
+
+      int DirCreate(const char* path);
+      int DirDelete(const char* path);
+
+      void VerifyResource();
+
+    private:
+
+      Pinetime::Drivers::SpiNorFlash& flashDriver;
+
+      /*
+      * External Flash MAP (4 MBytes)
+      *
+      * 0x000000 +---------------------------------------+
+      *          |  Bootloader Assets                    |
+      *          |  256 KBytes                           |
+      *          |                                       |
+      * 0x040000 +---------------------------------------+
+      *          |  OTA                                  |
+      *          |  464 KBytes                           |
+      *          |                                       |
+      *          |                                       |
+      *          |                                       |
+      * 0x0B4000 +---------------------------------------+
+      *          |  File System                          |
+      *          |                                       |
+      *          |                                       |
+      *          |                                       |
+      *          |                                       |
+      * 0x400000 +---------------------------------------+
+      *
+      */
+      static constexpr size_t startAddress = 0x0B4000;
+      static constexpr size_t size = 0x3C0000;
+      static constexpr size_t blockSize = 4096;
+
+      bool resourcesValid = false;
+      const struct lfs_config lfsConfig;
+
+      lfs_t lfs;
+
+      static int SectorSync(const struct lfs_config* c);
+      static int SectorErase(const struct lfs_config* c, lfs_block_t block);
+      static int SectorProg(const struct lfs_config* c, lfs_block_t block, lfs_off_t off, const void* buffer, lfs_size_t size);
+      static int SectorRead(const struct lfs_config* c, lfs_block_t block, lfs_off_t off, void* buffer, lfs_size_t size);
+
+    };
+  }
+}
diff --git a/src/components/settings/Settings.cpp b/src/components/settings/Settings.cpp
index 071940b8..37c09f91 100644
--- a/src/components/settings/Settings.cpp
+++ b/src/components/settings/Settings.cpp
@@ -4,108 +4,44 @@
 
 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} {
+Settings::Settings(Pinetime::Controllers::FS& fs) : fs {fs} {
 }
 
 void Settings::Init() {
 
   // Load default settings from Flash
-  LoadSettingsFromFlash();
+  LoadSettingsFromFile();
 }
 
 void Settings::SaveSettings() {
 
   // verify if is necessary to save
   if (settingsChanged) {
-    SaveSettingsToFlash();
+    SaveSettingsToFile();
   }
   settingsChanged = false;
 }
 
-bool Settings::FindHeader() {
-  SettingsHeader settingsHeader;
-  uint8_t bufferHead[sizeof(settingsHeader)];
-
-  for (uint8_t block = 0; block < 10; block++) {
+void Settings::LoadSettingsFromFile() {
+  SettingsData bufferSettings;
+  lfs_file_t settingsFile;
 
-    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;
-    }
+  if ( fs.FileOpen(&settingsFile, "/settings.dat", LFS_O_RDWR | LFS_O_CREAT) != LFS_ERR_OK) {
+    return;
   }
-  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();
+  fs.FileRead(&settingsFile, reinterpret_cast<uint8_t*>(&bufferSettings), sizeof(settings));
+  fs.FileClose(&settingsFile);
+  if ( bufferSettings.version == settingsVersion ) {
+    settings = bufferSettings;
   }
 }
 
-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
+void Settings::SaveSettingsToFile() {
+  lfs_file_t settingsFile;
 
-  if (settingsFlashBlock != 99) {
-    SetHeader(false);
+  if ( fs.FileOpen(&settingsFile, "/settings.dat", LFS_O_RDWR | LFS_O_CREAT) != LFS_ERR_OK) {
+    return;
   }
-
-  settingsFlashBlock++;
-  if (settingsFlashBlock > 9)
-    settingsFlashBlock = 0;
-
-  EraseBlock();
-  SetHeader(true);
-  SaveSettingsData();
+  fs.FileWrite(&settingsFile, reinterpret_cast<uint8_t*>(&settings), sizeof(settings));
+  fs.FileClose(&settingsFile);
 }
diff --git a/src/components/settings/Settings.h b/src/components/settings/Settings.h
index 4409425b..577455eb 100644
--- a/src/components/settings/Settings.h
+++ b/src/components/settings/Settings.h
@@ -2,25 +2,26 @@
 #include <cstdint>
 #include "components/datetime/DateTimeController.h"
 #include "components/brightness/BrightnessController.h"
-#include "drivers/SpiNorFlash.h"
+#include "components/fs/FS.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 };
+      enum class ClockType : uint8_t { H24, H12 };
+      enum class Vibration : uint8_t { ON, OFF };
+      enum class WakeUpMode : uint8_t { None, SingleTap, DoubleTap, RaiseWrist };
 
-      Settings(Pinetime::Drivers::SpiNorFlash& spiNorFlash);
+      Settings(Pinetime::Controllers::FS& fs);
 
       void Init();
       void SaveSettings();
 
       void SetClockFace(uint8_t face) {
-        if (face != settings.clockFace)
+        if (face != settings.clockFace) {
           settingsChanged = true;
+        }
         settings.clockFace = face;
       };
       uint8_t GetClockFace() const {
@@ -42,8 +43,9 @@ namespace Pinetime {
       };
 
       void SetClockType(ClockType clocktype) {
-        if (clocktype != settings.clockType)
+        if (clocktype != settings.clockType) {
           settingsChanged = true;
+        }
         settings.clockType = clocktype;
       };
       ClockType GetClockType() const {
@@ -51,8 +53,9 @@ namespace Pinetime {
       };
 
       void SetVibrationStatus(Vibration status) {
-        if (status != settings.vibrationStatus)
+        if (status != settings.vibrationStatus) {
           settingsChanged = true;
+        }
         settings.vibrationStatus = status;
       };
       Vibration GetVibrationStatus() const {
@@ -60,8 +63,9 @@ namespace Pinetime {
       };
 
       void SetScreenTimeOut(uint32_t timeout) {
-        if (timeout != settings.screenTimeOut)
+        if (timeout != settings.screenTimeOut) {
           settingsChanged = true;
+        }
         settings.screenTimeOut = timeout;
       };
       uint32_t GetScreenTimeOut() const {
@@ -69,8 +73,9 @@ namespace Pinetime {
       };
 
       void setWakeUpMode(WakeUpMode wakeUp) {
-        if (wakeUp != settings.wakeUpMode)
+        if (wakeUp != settings.wakeUpMode) {
           settingsChanged = true;
+        }
         settings.wakeUpMode = wakeUp;
       };
       WakeUpMode getWakeUpMode() const {
@@ -78,8 +83,9 @@ namespace Pinetime {
       };
 
       void SetBrightness(Controllers::BrightnessController::Levels level) {
-        if (level != settings.brightLevel)
+        if (level != settings.brightLevel) {
           settingsChanged = true;
+        }
         settings.brightLevel = level;
       };
       Controllers::BrightnessController::Levels GetBrightness() const {
@@ -87,25 +93,29 @@ namespace Pinetime {
       };
 
       void SetStepsGoal( uint32_t goal ) { 
-        if ( goal != settings.stepsGoal ) 
+        if ( goal != settings.stepsGoal ) {
           settingsChanged = true;
+        }
         settings.stepsGoal = goal; 
       };
       
       uint32_t GetStepsGoal() const { return settings.stepsGoal; };
 
     private:
-      Pinetime::Drivers::SpiNorFlash& spiNorFlash;
+      Pinetime::Controllers::FS& fs;
+
+      static constexpr uint32_t settingsVersion = 0x0001;
       struct SettingsData {
 
+        uint32_t version = settingsVersion;
+        uint32_t stepsGoal = 10000;
+        uint32_t screenTimeOut = 15000;
+
         ClockType clockType = ClockType::H24;
         Vibration vibrationStatus = Vibration::ON;
 
         uint8_t clockFace = 0;
 
-        uint32_t stepsGoal = 10000;
-        uint32_t screenTimeOut = 15000;
-
         WakeUpMode wakeUpMode = WakeUpMode::None;
 
         Controllers::BrightnessController::Levels brightLevel = Controllers::BrightnessController::Levels::Medium;
@@ -117,20 +127,8 @@ namespace Pinetime {
       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();
+      void LoadSettingsFromFile();
+      void SaveSettingsToFile();
     };
   }
 }
\ No newline at end of file
diff --git a/src/libs/littlefs b/src/libs/littlefs
new file mode 160000
index 00000000..ead50807
--- /dev/null
+++ b/src/libs/littlefs
@@ -0,0 +1 @@
+Subproject commit ead50807f1ca3fdf2da00b77a0ce02651ded2d13
diff --git a/src/libs/lv_conf.h b/src/libs/lv_conf.h
index a03a4833..e85eeb1f 100644
--- a/src/libs/lv_conf.h
+++ b/src/libs/lv_conf.h
@@ -204,7 +204,7 @@ e.g. "stm32f769xx.h" or "stm32f429xx.h" */
 
 /* 1: Enable file system (might be required for images */
 // TODO: Enable FS
-#define LV_USE_FILESYSTEM       0
+#define LV_USE_FILESYSTEM       1
 #if LV_USE_FILESYSTEM
 /*Declare the type of the user data of file system drivers (can be e.g. `void *`, `int`, `struct`)*/
 typedef void * lv_fs_drv_user_data_t;
@@ -236,7 +236,7 @@ typedef void * lv_fs_drv_user_data_t;
  * With complex image decoders (e.g. PNG or JPG) caching can save the continuous open/decode of images.
  * However the opened images might consume additional RAM.
  * LV_IMG_CACHE_DEF_SIZE must be >= 1 */
-#define LV_IMG_CACHE_DEF_SIZE       1
+#define LV_IMG_CACHE_DEF_SIZE       6
 
 /*Declare the type of the user data of image decoder (can be e.g. `void *`, `int`, `struct`)*/
 typedef void* lv_img_decoder_user_data_t;
diff --git a/src/main.cpp b/src/main.cpp
index 5832a78f..1b7015aa 100644
--- a/src/main.cpp
+++ b/src/main.cpp
@@ -35,6 +35,7 @@
 #include "components/motor/MotorController.h"
 #include "components/datetime/DateTimeController.h"
 #include "components/heartrate/HeartRateController.h"
+#include "components/fs/FS.h"
 #include "drivers/Spi.h"
 #include "drivers/SpiMaster.h"
 #include "drivers/SpiNorFlash.h"
@@ -108,10 +109,6 @@ void ble_manager_set_ble_disconnection_callback(void (*disconnection)());
 static constexpr uint8_t pinTouchIrq = 28;
 static constexpr uint8_t pinPowerPresentIrq = 19;
 
-Pinetime::Controllers::Settings settingsController {spiNorFlash};
-
-Pinetime::Controllers::MotorController motorController {settingsController};
-
 Pinetime::Controllers::HeartRateController heartRateController;
 Pinetime::Applications::HeartRateTask heartRateApp(heartRateSensor, heartRateController);
 
@@ -122,6 +119,11 @@ Pinetime::Controllers::NotificationManager notificationManager;
 Pinetime::Controllers::MotionController motionController;
 Pinetime::Controllers::TimerController timerController;
 
+Pinetime::Controllers::FS fs {spiNorFlash};
+Pinetime::Controllers::Settings settingsController {fs};
+Pinetime::Controllers::MotorController motorController {settingsController};
+
+
 Pinetime::Applications::DisplayApp displayApp(lcd,
                                               lvgl,
                                               touchPanel,
@@ -155,7 +157,8 @@ Pinetime::System::SystemTask systemTask(spi,
                                         settingsController,
                                         heartRateController,
                                         displayApp,
-                                        heartRateApp);
+                                        heartRateApp,
+                                        fs);
 
 void nrfx_gpiote_evt_handler(nrfx_gpiote_pin_t pin, nrf_gpiote_polarity_t action) {
   if (pin == pinTouchIrq) {
diff --git a/src/systemtask/SystemTask.cpp b/src/systemtask/SystemTask.cpp
index 13755f71..17e78230 100644
--- a/src/systemtask/SystemTask.cpp
+++ b/src/systemtask/SystemTask.cpp
@@ -59,7 +59,8 @@ SystemTask::SystemTask(Drivers::SpiMaster& spi,
                        Controllers::Settings& settingsController,
                        Pinetime::Controllers::HeartRateController& heartRateController,
                        Pinetime::Applications::DisplayApp& displayApp,
-                       Pinetime::Applications::HeartRateTask& heartRateApp)
+                       Pinetime::Applications::HeartRateTask& heartRateApp,
+                       Pinetime::Controllers::FS& fs)
   : spi {spi},
     lcd {lcd},
     spiNorFlash {spiNorFlash},
@@ -77,10 +78,11 @@ SystemTask::SystemTask(Drivers::SpiMaster& spi,
     motionSensor {motionSensor},
     settingsController {settingsController},
     heartRateController{heartRateController},
-    nimbleController(*this, bleController, dateTimeController, notificationManager, batteryController, spiNorFlash, heartRateController),
     motionController{motionController},
     displayApp{displayApp},
-    heartRateApp(heartRateApp) {
+    heartRateApp(heartRateApp),
+    fs{fs},
+    nimbleController(*this, bleController, dateTimeController, notificationManager, batteryController, spiNorFlash, heartRateController) {
 
 }
 
@@ -107,6 +109,9 @@ void SystemTask::Work() {
   spi.Init();
   spiNorFlash.Init();
   spiNorFlash.Wakeup();
+  
+  fs.Init();
+
   nimbleController.Init();
   nimbleController.StartAdvertising();
   brightnessController.Init();
diff --git a/src/systemtask/SystemTask.h b/src/systemtask/SystemTask.h
index f563640c..bfb97264 100644
--- a/src/systemtask/SystemTask.h
+++ b/src/systemtask/SystemTask.h
@@ -16,13 +16,15 @@
 #include "components/ble/NotificationManager.h"
 #include "components/motor/MotorController.h"
 #include "components/timer/TimerController.h"
+#include "components/fs/FS.h"
+
 #ifdef PINETIME_IS_RECOVERY
   #include "displayapp/DisplayAppRecovery.h"
   #include "displayapp/DummyLittleVgl.h"
 #else
   #include "components/settings/Settings.h"
   #include "displayapp/DisplayApp.h"
-  #include "displayapp/LittleVgl.h"
+  #include "displayapp/LittleVgl.h"  
 #endif
 
 #include "drivers/Watchdog.h"
@@ -59,7 +61,8 @@ namespace Pinetime {
                  Controllers::Settings& settingsController,
                  Pinetime::Controllers::HeartRateController& heartRateController,
                  Pinetime::Applications::DisplayApp& displayApp,
-                 Pinetime::Applications::HeartRateTask& heartRateApp);
+                 Pinetime::Applications::HeartRateTask& heartRateApp,
+                 Pinetime::Controllers::FS& fs);
 
       void Start();
       void PushMessage(Messages msg);
@@ -103,13 +106,14 @@ namespace Pinetime {
       Pinetime::Drivers::Bma421& motionSensor;
       Pinetime::Controllers::Settings& settingsController;
       Pinetime::Controllers::HeartRateController& heartRateController;
-      Pinetime::Controllers::NimbleController nimbleController;
+            
       Controllers::BrightnessController brightnessController;
       Pinetime::Controllers::MotionController& motionController;
 
       Pinetime::Applications::DisplayApp& displayApp;
       Pinetime::Applications::HeartRateTask& heartRateApp;
-
+      Pinetime::Controllers::FS& fs;
+      Pinetime::Controllers::NimbleController nimbleController;
 
       static constexpr uint8_t pinSpiSck = 2;
       static constexpr uint8_t pinSpiMosi = 3;
-- 
cgit v1.2.3-70-g09d2


From e21f6a7f414d1f832e8fddfeaab3b9de05aa3459 Mon Sep 17 00:00:00 2001
From: Jean-François Milants <jf@codingfield.com>
Date: Sun, 11 Jul 2021 16:55:06 +0200
Subject: Notify battery level every 10 minutes when connected to a BLE host.
 Refactor battery percent : only use uint8_t to store the battery % remaining.

---
 src/components/battery/BatteryController.cpp     | 13 ++---
 src/components/battery/BatteryController.h       | 18 ++++---
 src/components/ble/BatteryInformationService.cpp |  8 ++-
 src/components/ble/BatteryInformationService.h   |  2 +-
 src/components/ble/NimbleController.cpp          |  6 +++
 src/components/ble/NimbleController.h            |  3 +-
 src/displayapp/screens/BatteryIcon.cpp           |  3 +-
 src/displayapp/screens/BatteryIcon.h             |  2 +-
 src/displayapp/screens/BatteryInfo.cpp           | 66 ++++++++++--------------
 src/displayapp/screens/BatteryInfo.h             |  2 +-
 src/displayapp/screens/PineTimeStyle.h           |  2 +-
 src/displayapp/screens/SystemInfo.cpp            |  2 +-
 src/displayapp/screens/WatchFaceAnalog.cpp       |  1 -
 src/displayapp/screens/WatchFaceAnalog.h         |  2 +-
 src/displayapp/screens/WatchFaceDigital.h        |  2 +-
 src/systemtask/SystemTask.cpp                    |  5 ++
 src/systemtask/SystemTask.h                      |  2 +
 17 files changed, 71 insertions(+), 68 deletions(-)

(limited to 'src/systemtask/SystemTask.cpp')

diff --git a/src/components/battery/BatteryController.cpp b/src/components/battery/BatteryController.cpp
index 76ad8cb3..fa476ea3 100644
--- a/src/components/battery/BatteryController.cpp
+++ b/src/components/battery/BatteryController.cpp
@@ -1,9 +1,7 @@
 #include "BatteryController.h"
 #include <hal/nrf_gpio.h>
 #include <nrfx_saadc.h>
-#include <libraries/log/nrf_log.h>
 #include <algorithm>
-#include <math.h>
 
 using namespace Pinetime::Controllers;
 
@@ -18,7 +16,6 @@ void Battery::Init() {
 }
 
 void Battery::Update() {
-
   isCharging = !nrf_gpio_pin_read(chargingPin);
   isPowerPresent = !nrf_gpio_pin_read(powerPresentPin);
 
@@ -33,13 +30,13 @@ void Battery::Update() {
   nrfx_saadc_sample();
 }
 
-void Battery::adcCallbackStatic(nrfx_saadc_evt_t const* event) {
+void Battery::AdcCallbackStatic(nrfx_saadc_evt_t const* event) {
   instance->SaadcEventHandler(event);
 }
 
 void Battery::SaadcInit() {
   nrfx_saadc_config_t adcConfig = NRFX_SAADC_DEFAULT_CONFIG;
-  APP_ERROR_CHECK(nrfx_saadc_init(&adcConfig, adcCallbackStatic));
+  APP_ERROR_CHECK(nrfx_saadc_init(&adcConfig, AdcCallbackStatic));
 
   nrf_saadc_channel_config_t adcChannelConfig = {.resistor_p = NRF_SAADC_RESISTOR_DISABLED,
                                                  .resistor_n = NRF_SAADC_RESISTOR_DISABLED,
@@ -55,7 +52,6 @@ void Battery::SaadcInit() {
 }
 
 void Battery::SaadcEventHandler(nrfx_saadc_evt_t const* p_event) {
-
   const uint16_t battery_max = 4180; // maximum voltage of battery ( max charging voltage is 4.21 )
   const uint16_t battery_min = 3200; // minimum voltage of battery before shutdown ( depends on the battery )
 
@@ -69,13 +65,10 @@ void Battery::SaadcEventHandler(nrfx_saadc_evt_t const* p_event) {
     // reference_voltage is 0.6V
     // p_event->data.done.p_buffer[0] = (adc_voltage / reference_voltage) * 1024
     voltage = p_event->data.done.p_buffer[0] * 6000 / 1024;
-
     percentRemaining = (voltage - battery_min) * 100 / (battery_max - battery_min);
-
     percentRemaining = std::max(percentRemaining, 0);
     percentRemaining = std::min(percentRemaining, 100);
-
-    percentRemainingBuffer.insert(percentRemaining);
+    percentRemainingBuffer.Insert(percentRemaining);
 
     samples++;
     if (samples > percentRemainingSamples) {
diff --git a/src/components/battery/BatteryController.h b/src/components/battery/BatteryController.h
index 26e24938..1333ad0e 100644
--- a/src/components/battery/BatteryController.h
+++ b/src/components/battery/BatteryController.h
@@ -19,7 +19,7 @@ namespace Pinetime {
      insert member function overwrites the next data to the current
     HEAD and moves the HEAD to the newly inserted value.
     */
-      void insert(const int num) {
+      void Insert(const uint8_t num) {
         head %= cap;
         arr[head++] = num;
         if (sz != cap) {
@@ -27,13 +27,13 @@ namespace Pinetime {
         }
       }
 
-      int GetAverage() const {
+      uint8_t GetAverage() const {
         int sum = std::accumulate(arr.begin(), arr.end(), 0);
-        return (sum / sz);
+        return static_cast<uint8_t>(sum / sz);
       }
 
     private:
-      std::array<int, N> arr; /**< internal array used to store the values*/
+      std::array<uint8_t, N> arr; /**< internal array used to store the values*/
       uint8_t sz;             /**< The current size of the array.*/
       uint8_t cap;            /**< Total capacity of the CircBuffer.*/
       uint8_t head;           /**< The current head of the CircBuffer*/
@@ -46,8 +46,11 @@ namespace Pinetime {
       void Init();
       void Update();
 
-      int PercentRemaining() const {
-        return percentRemainingBuffer.GetAverage();
+      uint8_t PercentRemaining() const {
+        auto avg = percentRemainingBuffer.GetAverage();
+        avg = std::min(avg, static_cast<uint8_t>(100));
+        avg = std::max(avg, static_cast<uint8_t>(0));
+        return avg;
       }
 
       uint16_t Voltage() const {
@@ -57,6 +60,7 @@ namespace Pinetime {
       bool IsCharging() const {
         return isCharging;
       }
+
       bool IsPowerPresent() const {
         return isPowerPresent;
       }
@@ -80,7 +84,7 @@ namespace Pinetime {
       void SaadcInit();
 
       void SaadcEventHandler(nrfx_saadc_evt_t const* p_event);
-      static void adcCallbackStatic(nrfx_saadc_evt_t const* event);
+      static void AdcCallbackStatic(nrfx_saadc_evt_t const* event);
 
       bool isReading = false;
       uint8_t samples = 0;
diff --git a/src/components/ble/BatteryInformationService.cpp b/src/components/ble/BatteryInformationService.cpp
index 10a78d67..7f176904 100644
--- a/src/components/ble/BatteryInformationService.cpp
+++ b/src/components/ble/BatteryInformationService.cpp
@@ -17,7 +17,7 @@ BatteryInformationService::BatteryInformationService(Controllers::Battery& batte
     characteristicDefinition {{.uuid = (ble_uuid_t*) &batteryLevelUuid,
                                .access_cb = BatteryInformationServiceCallback,
                                .arg = this,
-                               .flags = BLE_GATT_CHR_F_READ,
+                               .flags = BLE_GATT_CHR_F_READ | BLE_GATT_CHR_F_NOTIFY,
                                .val_handle = &batteryLevelHandle},
                               {0}},
     serviceDefinition {
@@ -48,4 +48,8 @@ int BatteryInformationService::OnBatteryServiceRequested(uint16_t connectionHand
     return (res == 0) ? 0 : BLE_ATT_ERR_INSUFFICIENT_RES;
   }
   return 0;
-}
\ No newline at end of file
+}
+void BatteryInformationService::NotifyBatteryLevel(uint16_t connectionHandle, uint8_t level) {
+  auto* om = ble_hs_mbuf_from_flat(&level, 1);
+  ble_gattc_notify_custom(connectionHandle, batteryLevelHandle, om);
+}
diff --git a/src/components/ble/BatteryInformationService.h b/src/components/ble/BatteryInformationService.h
index 7d060909..1303fd6c 100644
--- a/src/components/ble/BatteryInformationService.h
+++ b/src/components/ble/BatteryInformationService.h
@@ -17,7 +17,7 @@ namespace Pinetime {
       void Init();
 
       int OnBatteryServiceRequested(uint16_t connectionHandle, uint16_t attributeHandle, ble_gatt_access_ctxt* context);
-
+      void NotifyBatteryLevel(uint16_t connectionHandle, uint8_t level);
     private:
       Controllers::Battery& batteryController;
       static constexpr uint16_t batteryInformationServiceId {0x180F};
diff --git a/src/components/ble/NimbleController.cpp b/src/components/ble/NimbleController.cpp
index 2c1d0f99..5eb227bf 100644
--- a/src/components/ble/NimbleController.cpp
+++ b/src/components/ble/NimbleController.cpp
@@ -235,3 +235,9 @@ void NimbleController::StartDiscovery() {
 uint16_t NimbleController::connHandle() {
   return connectionHandle;
 }
+
+void NimbleController::NotifyBatteryLevel(uint8_t level) {
+  if(connectionHandle != BLE_HS_CONN_HANDLE_NONE) {
+    batteryInformationService.NotifyBatteryLevel(connectionHandle, level);
+  }
+}
diff --git a/src/components/ble/NimbleController.h b/src/components/ble/NimbleController.h
index 5dd01e42..0cfe983c 100644
--- a/src/components/ble/NimbleController.h
+++ b/src/components/ble/NimbleController.h
@@ -70,6 +70,7 @@ namespace Pinetime {
       };
 
       uint16_t connHandle();
+      void NotifyBatteryLevel(uint8_t level);
 
     private:
       static constexpr const char* deviceName = "InfiniTime";
@@ -92,7 +93,7 @@ namespace Pinetime {
       HeartRateService heartRateService;
 
       uint8_t addrType; // 1 = Random, 0 = PUBLIC
-      uint16_t connectionHandle = 0;
+      uint16_t connectionHandle = BLE_HS_CONN_HANDLE_NONE;
 
       ble_uuid128_t dfuServiceUuid {
         .u {.type = BLE_UUID_TYPE_128},
diff --git a/src/displayapp/screens/BatteryIcon.cpp b/src/displayapp/screens/BatteryIcon.cpp
index 6b54a305..bb6626a5 100644
--- a/src/displayapp/screens/BatteryIcon.cpp
+++ b/src/displayapp/screens/BatteryIcon.cpp
@@ -1,9 +1,10 @@
+#include <cstdint>
 #include "BatteryIcon.h"
 #include "Symbols.h"
 
 using namespace Pinetime::Applications::Screens;
 
-const char* BatteryIcon::GetBatteryIcon(int batteryPercent) {
+const char* BatteryIcon::GetBatteryIcon(uint8_t batteryPercent) {
   if (batteryPercent > 90)
     return Symbols::batteryFull;
   if (batteryPercent > 75)
diff --git a/src/displayapp/screens/BatteryIcon.h b/src/displayapp/screens/BatteryIcon.h
index 9c192ff7..b370b331 100644
--- a/src/displayapp/screens/BatteryIcon.h
+++ b/src/displayapp/screens/BatteryIcon.h
@@ -6,7 +6,7 @@ namespace Pinetime {
       class BatteryIcon {
       public:
         static const char* GetUnknownIcon();
-        static const char* GetBatteryIcon(int batteryPercent);
+        static const char* GetBatteryIcon(uint8_t batteryPercent);
         static const char* GetPlugIcon(bool isCharging);
       };
     }
diff --git a/src/displayapp/screens/BatteryInfo.cpp b/src/displayapp/screens/BatteryInfo.cpp
index 87c8b4bb..2af024e7 100644
--- a/src/displayapp/screens/BatteryInfo.cpp
+++ b/src/displayapp/screens/BatteryInfo.cpp
@@ -38,11 +38,7 @@ BatteryInfo::BatteryInfo(Pinetime::Applications::DisplayApp* app, Pinetime::Cont
 
   percent = lv_label_create(lv_scr_act(), nullptr);
   lv_obj_set_style_local_text_font(percent, LV_LABEL_PART_MAIN, LV_STATE_DEFAULT, &jetbrains_mono_76);
-  if (batteryPercent >= 0) {
-    lv_label_set_text_fmt(percent, "%02i%%", batteryPercent);
-  } else {
-    lv_label_set_text(percent, "--%");
-  }
+  lv_label_set_text_fmt(percent, "%02i%%", batteryPercent);
   lv_label_set_align(percent, LV_LABEL_ALIGN_LEFT);
   lv_obj_align(percent, nullptr, LV_ALIGN_CENTER, 0, -60);
 
@@ -72,24 +68,22 @@ BatteryInfo::~BatteryInfo() {
 void BatteryInfo::UpdateAnim() {
   batteryPercent = batteryController.PercentRemaining();
 
-  if (batteryPercent >= 0) {
-    if (batteryController.IsCharging() and batteryPercent < 100) {
-      animation += 1;
-      if (animation >= 100) {
-        animation = 0;
-      }
-
-    } else {
-      if (animation > batteryPercent) {
-        animation--;
-      }
-      if (animation < batteryPercent) {
-        animation++;
-      }
+  if (batteryController.IsCharging() and batteryPercent < 100) {
+    animation += 1;
+    if (animation >= 100) {
+      animation = 0;
     }
 
-    lv_bar_set_value(charging_bar, animation, LV_ANIM_OFF);
+  } else {
+    if (animation > batteryPercent) {
+      animation--;
+    }
+    if (animation < batteryPercent) {
+      animation++;
+    }
   }
+
+  lv_bar_set_value(charging_bar, animation, LV_ANIM_OFF);
 }
 
 void BatteryInfo::UpdateScreen() {
@@ -99,28 +93,22 @@ void BatteryInfo::UpdateScreen() {
   batteryPercent = batteryController.PercentRemaining();
   batteryVoltage = batteryController.Voltage();
 
-  if (batteryPercent >= 0) {
-    if (batteryController.IsCharging() and batteryPercent < 100) {
-      lv_obj_set_style_local_bg_color(charging_bar, LV_BAR_PART_INDIC, LV_STATE_DEFAULT, LV_COLOR_RED);
-      lv_label_set_text_static(status, "Battery charging");
-    } else if (batteryPercent == 100) {
-      lv_obj_set_style_local_bg_color(charging_bar, LV_BAR_PART_INDIC, LV_STATE_DEFAULT, LV_COLOR_BLUE);
-      lv_label_set_text_static(status, "Battery is fully charged");
-    } else if (batteryPercent < 10) {
-      lv_obj_set_style_local_bg_color(charging_bar, LV_BAR_PART_INDIC, LV_STATE_DEFAULT, LV_COLOR_YELLOW);
-      lv_label_set_text_static(status, "Battery is low");
-    } else {
-      lv_obj_set_style_local_bg_color(charging_bar, LV_BAR_PART_INDIC, LV_STATE_DEFAULT, LV_COLOR_GREEN);
-      lv_label_set_text_static(status, "Battery discharging");
-    }
-
-    lv_label_set_text_fmt(percent, "%02i%%", batteryPercent);
-
+  if (batteryController.IsCharging() and batteryPercent < 100) {
+    lv_obj_set_style_local_bg_color(charging_bar, LV_BAR_PART_INDIC, LV_STATE_DEFAULT, LV_COLOR_RED);
+    lv_label_set_text_static(status, "Battery charging");
+  } else if (batteryPercent == 100) {
+    lv_obj_set_style_local_bg_color(charging_bar, LV_BAR_PART_INDIC, LV_STATE_DEFAULT, LV_COLOR_BLUE);
+    lv_label_set_text_static(status, "Battery is fully charged");
+  } else if (batteryPercent < 10) {
+    lv_obj_set_style_local_bg_color(charging_bar, LV_BAR_PART_INDIC, LV_STATE_DEFAULT, LV_COLOR_YELLOW);
+    lv_label_set_text_static(status, "Battery is low");
   } else {
-    lv_label_set_text_static(status, "Reading Battery status");
-    lv_label_set_text(percent, "--%");
+    lv_obj_set_style_local_bg_color(charging_bar, LV_BAR_PART_INDIC, LV_STATE_DEFAULT, LV_COLOR_GREEN);
+    lv_label_set_text_static(status, "Battery discharging");
   }
 
+  lv_label_set_text_fmt(percent, "%02i%%", batteryPercent);
+
   lv_obj_align(status, charging_bar, LV_ALIGN_OUT_BOTTOM_MID, 0, 20);
   lv_label_set_text_fmt(voltage, "%1i.%02i volts", batteryVoltage / 1000, batteryVoltage % 1000 / 10);
 }
diff --git a/src/displayapp/screens/BatteryInfo.h b/src/displayapp/screens/BatteryInfo.h
index 346dc571..da85c6dd 100644
--- a/src/displayapp/screens/BatteryInfo.h
+++ b/src/displayapp/screens/BatteryInfo.h
@@ -36,7 +36,7 @@ namespace Pinetime {
         lv_task_t* taskAnim;
 
         int8_t animation = 0;
-        int8_t batteryPercent = -1;
+        uint8_t batteryPercent = 0;
         uint16_t batteryVoltage = 0;
       };
     }
diff --git a/src/displayapp/screens/PineTimeStyle.h b/src/displayapp/screens/PineTimeStyle.h
index 70794cc5..3b4ded1e 100644
--- a/src/displayapp/screens/PineTimeStyle.h
+++ b/src/displayapp/screens/PineTimeStyle.h
@@ -42,7 +42,7 @@ namespace Pinetime {
         Pinetime::Controllers::DateTime::Days currentDayOfWeek = Pinetime::Controllers::DateTime::Days::Unknown;
         uint8_t currentDay = 0;
 
-        DirtyValue<int> batteryPercentRemaining {};
+        DirtyValue<uint8_t> batteryPercentRemaining {};
         DirtyValue<bool> bleState {};
         DirtyValue<std::chrono::time_point<std::chrono::system_clock, std::chrono::nanoseconds>> currentDateTime {};
         DirtyValue<bool> motionSensorOk {};
diff --git a/src/displayapp/screens/SystemInfo.cpp b/src/displayapp/screens/SystemInfo.cpp
index 5ae3a595..f5bf0cc9 100644
--- a/src/displayapp/screens/SystemInfo.cpp
+++ b/src/displayapp/screens/SystemInfo.cpp
@@ -103,7 +103,7 @@ std::unique_ptr<Screen> SystemInfo::CreateScreen1() {
 }
 
 std::unique_ptr<Screen> SystemInfo::CreateScreen2() {
-  auto batteryPercent = static_cast<uint8_t>(batteryController.PercentRemaining());
+  auto batteryPercent = batteryController.PercentRemaining();
   auto resetReason = [this]() {
     switch (watchdog.ResetReason()) {
       case Drivers::Watchdog::ResetReasons::Watchdog:
diff --git a/src/displayapp/screens/WatchFaceAnalog.cpp b/src/displayapp/screens/WatchFaceAnalog.cpp
index 0051408c..b0eb65bc 100644
--- a/src/displayapp/screens/WatchFaceAnalog.cpp
+++ b/src/displayapp/screens/WatchFaceAnalog.cpp
@@ -165,7 +165,6 @@ void WatchFaceAnalog::UpdateClock() {
 }
 
 bool WatchFaceAnalog::Refresh() {
-
   batteryPercentRemaining = batteryController.PercentRemaining();
   if (batteryPercentRemaining.IsUpdated()) {
     auto batteryPercent = batteryPercentRemaining.Get();
diff --git a/src/displayapp/screens/WatchFaceAnalog.h b/src/displayapp/screens/WatchFaceAnalog.h
index 96225558..ac7f0ac5 100644
--- a/src/displayapp/screens/WatchFaceAnalog.h
+++ b/src/displayapp/screens/WatchFaceAnalog.h
@@ -48,7 +48,7 @@ namespace Pinetime {
         Pinetime::Controllers::DateTime::Days currentDayOfWeek = Pinetime::Controllers::DateTime::Days::Unknown;
         uint8_t currentDay = 0;
 
-        DirtyValue<float> batteryPercentRemaining {0};
+        DirtyValue<uint8_t> batteryPercentRemaining {0};
         DirtyValue<std::chrono::time_point<std::chrono::system_clock, std::chrono::nanoseconds>> currentDateTime;
         DirtyValue<bool> notificationState {false};
 
diff --git a/src/displayapp/screens/WatchFaceDigital.h b/src/displayapp/screens/WatchFaceDigital.h
index 246efc95..76c8d3dc 100644
--- a/src/displayapp/screens/WatchFaceDigital.h
+++ b/src/displayapp/screens/WatchFaceDigital.h
@@ -45,7 +45,7 @@ namespace Pinetime {
         Pinetime::Controllers::DateTime::Days currentDayOfWeek = Pinetime::Controllers::DateTime::Days::Unknown;
         uint8_t currentDay = 0;
 
-        DirtyValue<int> batteryPercentRemaining {};
+        DirtyValue<uint8_t> batteryPercentRemaining {};
         DirtyValue<bool> bleState {};
         DirtyValue<std::chrono::time_point<std::chrono::system_clock, std::chrono::nanoseconds>> currentDateTime {};
         DirtyValue<bool> motionSensorOk {};
diff --git a/src/systemtask/SystemTask.cpp b/src/systemtask/SystemTask.cpp
index 17e78230..eb29638a 100644
--- a/src/systemtask/SystemTask.cpp
+++ b/src/systemtask/SystemTask.cpp
@@ -330,6 +330,11 @@ void SystemTask::Work() {
       }
     }
 
+    if (xTaskGetTickCount() - batteryNotificationTick > batteryNotificationPeriod) {
+      nimbleController.NotifyBatteryLevel(batteryController.PercentRemaining());
+      batteryNotificationTick = xTaskGetTickCount();
+    }
+
     monitor.Process();
     uint32_t systick_counter = nrf_rtc_counter_get(portNRF_RTC_REG);
     dateTimeController.UpdateTime(systick_counter);
diff --git a/src/systemtask/SystemTask.h b/src/systemtask/SystemTask.h
index bfb97264..f8cf6370 100644
--- a/src/systemtask/SystemTask.h
+++ b/src/systemtask/SystemTask.h
@@ -135,6 +135,8 @@ namespace Pinetime {
       void GoToRunning();
       void UpdateMotion();
       bool stepCounterMustBeReset = false;
+      static constexpr TickType_t batteryNotificationPeriod = 1000 * 60 * 10; // 1 tick ~= 1ms. 1ms * 60 * 10 = 10 minutes
+      TickType_t batteryNotificationTick = 0;
 
 #if configUSE_TRACE_FACILITY == 1
       SystemMonitor<FreeRtosMonitor> monitor;
-- 
cgit v1.2.3-70-g09d2