Merge remote-tracking branch 'upstream/develop' into pts-settings

39 files changed, 777 insertions, 223 deletions

diff --git a/src/BootErrors.h b/src/BootErrors.h
new file mode 100644
index 00000000..d00418cc
--- /dev/null
+++ b/src/BootErrors.h
@@ -0,0 +1,10 @@
+#pragma once
+
+namespace Pinetime {
+  namespace System {
+    enum class BootErrors {
+      None,
+      TouchController,
+    };
+  }
+}
diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt
index 52f0bc8e..0616c9d7 100644
--- a/src/CMakeLists.txt
+++ b/src/CMakeLists.txt
@@ -421,6 +421,7 @@ list(APPEND SOURCE_FILES
         displayapp/screens/BatteryInfo.cpp
         displayapp/screens/Steps.cpp
         displayapp/screens/Timer.cpp
+        displayapp/screens/Error.cpp
         displayapp/screens/Alarm.cpp
         displayapp/Colors.cpp
 
@@ -432,6 +433,8 @@ list(APPEND SOURCE_FILES
         displayapp/screens/settings/SettingWakeUp.cpp
         displayapp/screens/settings/SettingDisplay.cpp
         displayapp/screens/settings/SettingSteps.cpp
+        displayapp/screens/settings/SettingSetDate.cpp
+        displayapp/screens/settings/SettingSetTime.cpp
 
         ## Watch faces
         displayapp/icons/bg_clock.c
diff --git a/src/components/battery/BatteryController.cpp b/src/components/battery/BatteryController.cpp
index b43b229f..e807f033 100644
--- a/src/components/battery/BatteryController.cpp
+++ b/src/components/battery/BatteryController.cpp
@@ -13,7 +13,7 @@ Battery::Battery() {
   nrf_gpio_cfg_input(PinMap::Charging, static_cast<nrf_gpio_pin_pull_t> GPIO_PIN_CNF_PULL_Disabled);
 }
 
-void Battery::Update() {
+void Battery::ReadPowerState() {
   isCharging = !nrf_gpio_pin_read(PinMap::Charging);
   isPowerPresent = !nrf_gpio_pin_read(PinMap::PowerPresent);
 
@@ -22,6 +22,10 @@ void Battery::Update() {
   } else if (!isPowerPresent) {
     isFull = false;
   }
+}
+
+void Battery::MeasureVoltage() {
+  ReadPowerState();
 
   if (isReading) {
     return;
@@ -69,18 +73,23 @@ void Battery::SaadcEventHandler(nrfx_saadc_evt_t const* p_event) {
     // p_event->data.done.p_buffer[0] = (adc_voltage / reference_voltage) * 1024
     voltage = p_event->data.done.p_buffer[0] * (8 * 600) / 1024;
 
+    uint8_t newPercent;
     if (isFull) {
-      percentRemaining = 100;
+      newPercent = 100;
     } else if (voltage < battery_min) {
-      percentRemaining = 0;
+      newPercent = 0;
     } else {
-      percentRemaining = std::min((voltage - battery_min) * 100 / (battery_max - battery_min), isCharging ? 99 : 100);
+      newPercent = std::min((voltage - battery_min) * 100 / (battery_max - battery_min), isCharging ? 99 : 100);
+    }
+
+    if ((isPowerPresent && newPercent > percentRemaining) || (!isPowerPresent && newPercent < percentRemaining) || firstMeasurement) {
+      firstMeasurement = false;
+      percentRemaining = newPercent;
+      systemTask->PushMessage(System::Messages::BatteryPercentageUpdated);
     }
 
     nrfx_saadc_uninit();
     isReading = false;
-
-    systemTask->PushMessage(System::Messages::BatteryMeasurementDone);
   }
 }
 
diff --git a/src/components/battery/BatteryController.h b/src/components/battery/BatteryController.h
index c78ffb3f..5a7394c4 100644
--- a/src/components/battery/BatteryController.h
+++ b/src/components/battery/BatteryController.h
@@ -10,7 +10,8 @@ namespace Pinetime {
     public:
       Battery();
 
-      void Update();
+      void ReadPowerState();
+      void MeasureVoltage();
       void Register(System::SystemTask* systemTask);
 
       uint8_t PercentRemaining() const {
@@ -42,6 +43,7 @@ namespace Pinetime {
       bool isFull = false;
       bool isCharging = false;
       bool isPowerPresent = false;
+      bool firstMeasurement = true;
 
       void SaadcInit();
 
diff --git a/src/components/ble/AlertNotificationClient.cpp b/src/components/ble/AlertNotificationClient.cpp
index c3d1d69a..5e5c25cf 100644
--- a/src/components/ble/AlertNotificationClient.cpp
+++ b/src/components/ble/AlertNotificationClient.cpp
@@ -55,7 +55,7 @@ bool AlertNotificationClient::OnDiscoveryEvent(uint16_t connectionHandle, const
     return true;
   }
 
-  if (service != nullptr && ble_uuid_cmp(((ble_uuid_t*) &ansServiceUuid), &service->uuid.u) == 0) {
+  if (service != nullptr && ble_uuid_cmp(&ansServiceUuid.u, &service->uuid.u) == 0) {
     NRF_LOG_INFO("ANS discovered : 0x%x - 0x%x", service->start_handle, service->end_handle);
     ansStartHandle = service->start_handle;
     ansEndHandle = service->end_handle;
@@ -80,21 +80,21 @@ int AlertNotificationClient::OnCharacteristicsDiscoveryEvent(uint16_t connection
     } else
       onServiceDiscovered(connectionHandle);
   } else {
-    if (characteristic != nullptr && ble_uuid_cmp(((ble_uuid_t*) &supportedNewAlertCategoryUuid), &characteristic->uuid.u) == 0) {
+    if (characteristic != nullptr && ble_uuid_cmp(&supportedNewAlertCategoryUuid.u, &characteristic->uuid.u) == 0) {
       NRF_LOG_INFO("ANS Characteristic discovered : supportedNewAlertCategoryUuid");
       supportedNewAlertCategoryHandle = characteristic->val_handle;
-    } else if (characteristic != nullptr && ble_uuid_cmp(((ble_uuid_t*) &supportedUnreadAlertCategoryUuid), &characteristic->uuid.u) == 0) {
+    } else if (characteristic != nullptr && ble_uuid_cmp(&supportedUnreadAlertCategoryUuid.u, &characteristic->uuid.u) == 0) {
       NRF_LOG_INFO("ANS Characteristic discovered : supportedUnreadAlertCategoryUuid");
       supportedUnreadAlertCategoryHandle = characteristic->val_handle;
-    } else if (characteristic != nullptr && ble_uuid_cmp(((ble_uuid_t*) &newAlertUuid), &characteristic->uuid.u) == 0) {
+    } else if (characteristic != nullptr && ble_uuid_cmp(&newAlertUuid.u, &characteristic->uuid.u) == 0) {
       NRF_LOG_INFO("ANS Characteristic discovered : newAlertUuid");
       newAlertHandle = characteristic->val_handle;
       newAlertDefHandle = characteristic->def_handle;
       isCharacteristicDiscovered = true;
-    } else if (characteristic != nullptr && ble_uuid_cmp(((ble_uuid_t*) &unreadAlertStatusUuid), &characteristic->uuid.u) == 0) {
+    } else if (characteristic != nullptr && ble_uuid_cmp(&unreadAlertStatusUuid.u, &characteristic->uuid.u) == 0) {
       NRF_LOG_INFO("ANS Characteristic discovered : unreadAlertStatusUuid");
       unreadAlertStatusHandle = characteristic->val_handle;
-    } else if (characteristic != nullptr && ble_uuid_cmp(((ble_uuid_t*) &controlPointUuid), &characteristic->uuid.u) == 0) {
+    } else if (characteristic != nullptr && ble_uuid_cmp(&controlPointUuid.u, &characteristic->uuid.u) == 0) {
       NRF_LOG_INFO("ANS Characteristic discovered : controlPointUuid");
       controlPointHandle = characteristic->val_handle;
     } else
@@ -119,7 +119,7 @@ int AlertNotificationClient::OnDescriptorDiscoveryEventCallback(uint16_t connect
                                                                 uint16_t characteristicValueHandle,
                                                                 const ble_gatt_dsc* descriptor) {
   if (error->status == 0) {
-    if (characteristicValueHandle == newAlertHandle && ble_uuid_cmp(((ble_uuid_t*) &newAlertUuid), &descriptor->uuid.u)) {
+    if (characteristicValueHandle == newAlertHandle && ble_uuid_cmp(&newAlertUuid.u, &descriptor->uuid.u)) {
       if (newAlertDescriptorHandle == 0) {
         NRF_LOG_INFO("ANS Descriptor discovered : %d", descriptor->handle);
         newAlertDescriptorHandle = descriptor->handle;
diff --git a/src/components/ble/AlertNotificationService.cpp b/src/components/ble/AlertNotificationService.cpp
index d5fc7f65..56fc595f 100644
--- a/src/components/ble/AlertNotificationService.cpp
+++ b/src/components/ble/AlertNotificationService.cpp
@@ -26,11 +26,8 @@ void AlertNotificationService::Init() {
 }
 
 AlertNotificationService::AlertNotificationService(System::SystemTask& systemTask, NotificationManager& notificationManager)
-  : characteristicDefinition {{.uuid = (ble_uuid_t*) &ansCharUuid,
-                               .access_cb = AlertNotificationCallback,
-                               .arg = this,
-                               .flags = BLE_GATT_CHR_F_WRITE},
-                              {.uuid = (ble_uuid_t*) &notificationEventUuid,
+  : characteristicDefinition {{.uuid = &ansCharUuid.u, .access_cb = AlertNotificationCallback, .arg = this, .flags = BLE_GATT_CHR_F_WRITE},
+                              {.uuid = &notificationEventUuid.u,
                                .access_cb = AlertNotificationCallback,
                                .arg = this,
                                .flags = BLE_GATT_CHR_F_NOTIFY,
@@ -39,7 +36,7 @@ AlertNotificationService::AlertNotificationService(System::SystemTask& systemTas
     serviceDefinition {
       {/* Device Information Service */
        .type = BLE_GATT_SVC_TYPE_PRIMARY,
-       .uuid = (ble_uuid_t*) &ansUuid,
+       .uuid = &ansUuid.u,
        .characteristics = characteristicDefinition},
       {0},
     },
@@ -123,4 +120,4 @@ void AlertNotificationService::MuteIncomingCall() {
   }
 
   ble_gattc_notify_custom(connectionHandle, eventHandle, om);
-}
\ No newline at end of file
+}
diff --git a/src/components/ble/BatteryInformationService.cpp b/src/components/ble/BatteryInformationService.cpp
index 4ef02358..29178667 100644
--- a/src/components/ble/BatteryInformationService.cpp
+++ b/src/components/ble/BatteryInformationService.cpp
@@ -14,7 +14,7 @@ int BatteryInformationServiceCallback(uint16_t conn_handle, uint16_t attr_handle
 
 BatteryInformationService::BatteryInformationService(Controllers::Battery& batteryController)
   : batteryController {batteryController},
-    characteristicDefinition {{.uuid = (ble_uuid_t*) &batteryLevelUuid,
+    characteristicDefinition {{.uuid = &batteryLevelUuid.u,
                                .access_cb = BatteryInformationServiceCallback,
                                .arg = this,
                                .flags = BLE_GATT_CHR_F_READ | BLE_GATT_CHR_F_NOTIFY,
@@ -23,7 +23,7 @@ BatteryInformationService::BatteryInformationService(Controllers::Battery& batte
     serviceDefinition {
       {/* Device Information Service */
        .type = BLE_GATT_SVC_TYPE_PRIMARY,
-       .uuid = (ble_uuid_t*) &batteryInformationServiceUuid,
+       .uuid = &batteryInformationServiceUuid.u,
        .characteristics = characteristicDefinition},
       {0},
     } {
diff --git a/src/components/ble/CurrentTimeClient.cpp b/src/components/ble/CurrentTimeClient.cpp
index c6e68312..90d1f0c7 100644
--- a/src/components/ble/CurrentTimeClient.cpp
+++ b/src/components/ble/CurrentTimeClient.cpp
@@ -47,7 +47,7 @@ bool CurrentTimeClient::OnDiscoveryEvent(uint16_t connectionHandle, const ble_ga
     return true;
   }
 
-  if (service != nullptr && ble_uuid_cmp(((ble_uuid_t*) &ctsServiceUuid), &service->uuid.u) == 0) {
+  if (service != nullptr && ble_uuid_cmp(&ctsServiceUuid.u, &service->uuid.u) == 0) {
     NRF_LOG_INFO("CTS discovered : 0x%x - 0x%x", service->start_handle, service->end_handle);
     isDiscovered = true;
     ctsStartHandle = service->start_handle;
@@ -72,7 +72,7 @@ int CurrentTimeClient::OnCharacteristicDiscoveryEvent(uint16_t conn_handle,
     return 0;
   }
 
-  if (characteristic != nullptr && ble_uuid_cmp(((ble_uuid_t*) &currentTimeCharacteristicUuid), &characteristic->uuid.u) == 0) {
+  if (characteristic != nullptr && ble_uuid_cmp(&currentTimeCharacteristicUuid.u, &characteristic->uuid.u) == 0) {
     NRF_LOG_INFO("CTS Characteristic discovered : 0x%x", characteristic->val_handle);
     isCharacteristicDiscovered = true;
     currentTimeHandle = characteristic->val_handle;
diff --git a/src/components/ble/CurrentTimeService.cpp b/src/components/ble/CurrentTimeService.cpp
index b49be39c..eefb7ec1 100644
--- a/src/components/ble/CurrentTimeService.cpp
+++ b/src/components/ble/CurrentTimeService.cpp
@@ -53,7 +53,7 @@ int CurrentTimeService::OnTimeAccessed(uint16_t conn_handle, uint16_t attr_handl
 }
 
 CurrentTimeService::CurrentTimeService(DateTime& dateTimeController)
-  : characteristicDefinition {{.uuid = (ble_uuid_t*) &ctChrUuid,
+  : characteristicDefinition {{.uuid = &ctChrUuid.u,
                                .access_cb = CTSCallback,
 
                                .arg = this,
@@ -62,7 +62,7 @@ CurrentTimeService::CurrentTimeService(DateTime& dateTimeController)
     serviceDefinition {
       {/* Device Information Service */
        .type = BLE_GATT_SVC_TYPE_PRIMARY,
-       .uuid = (ble_uuid_t*) &ctsUuid,
+       .uuid = &ctsUuid.u,
        .characteristics = characteristicDefinition},
       {0},
     },
diff --git a/src/components/ble/DeviceInformationService.cpp b/src/components/ble/DeviceInformationService.cpp
index cf482079..778d6e35 100644
--- a/src/components/ble/DeviceInformationService.cpp
+++ b/src/components/ble/DeviceInformationService.cpp
@@ -56,37 +56,37 @@ int DeviceInformationService::OnDeviceInfoRequested(uint16_t conn_handle, uint16
 
 DeviceInformationService::DeviceInformationService()
   : characteristicDefinition {{
-                                .uuid = (ble_uuid_t*) &manufacturerNameUuid,
+                                .uuid = &manufacturerNameUuid.u,
                                 .access_cb = DeviceInformationCallback,
                                 .arg = this,
                                 .flags = BLE_GATT_CHR_F_READ,
                               },
                               {
-                                .uuid = (ble_uuid_t*) &modelNumberUuid,
+                                .uuid = &modelNumberUuid.u,
                                 .access_cb = DeviceInformationCallback,
                                 .arg = this,
                                 .flags = BLE_GATT_CHR_F_READ,
                               },
                               {
-                                .uuid = (ble_uuid_t*) &serialNumberUuid,
+                                .uuid = &serialNumberUuid.u,
                                 .access_cb = DeviceInformationCallback,
                                 .arg = this,
                                 .flags = BLE_GATT_CHR_F_READ,
                               },
                               {
-                                .uuid = (ble_uuid_t*) &fwRevisionUuid,
+                                .uuid = &fwRevisionUuid.u,
                                 .access_cb = DeviceInformationCallback,
                                 .arg = this,
                                 .flags = BLE_GATT_CHR_F_READ,
                               },
                               {
-                                .uuid = (ble_uuid_t*) &hwRevisionUuid,
+                                .uuid = &hwRevisionUuid.u,
                                 .access_cb = DeviceInformationCallback,
                                 .arg = this,
                                 .flags = BLE_GATT_CHR_F_READ,
                               },
                               {
-                                .uuid = (ble_uuid_t*) &swRevisionUuid,
+                                .uuid = &swRevisionUuid.u,
                                 .access_cb = DeviceInformationCallback,
                                 .arg = this,
                                 .flags = BLE_GATT_CHR_F_READ,
@@ -95,7 +95,7 @@ DeviceInformationService::DeviceInformationService()
     serviceDefinition {
       {/* Device Information Service */
        .type = BLE_GATT_SVC_TYPE_PRIMARY,
-       .uuid = (ble_uuid_t*) &deviceInfoUuid,
+       .uuid = &deviceInfoUuid.u,
        .characteristics = characteristicDefinition},
       {0},
     } {
diff --git a/src/components/ble/DfuService.cpp b/src/components/ble/DfuService.cpp
index 4179994d..3d6416fa 100644
--- a/src/components/ble/DfuService.cpp
+++ b/src/components/ble/DfuService.cpp
@@ -33,21 +33,21 @@ DfuService::DfuService(Pinetime::System::SystemTask& systemTask,
     bleController {bleController},
     dfuImage {spiNorFlash},
     characteristicDefinition {{
-                                .uuid = (ble_uuid_t*) &packetCharacteristicUuid,
+                                .uuid = &packetCharacteristicUuid.u,
                                 .access_cb = DfuServiceCallback,
                                 .arg = this,
                                 .flags = BLE_GATT_CHR_F_WRITE_NO_RSP,
                                 .val_handle = nullptr,
                               },
                               {
-                                .uuid = (ble_uuid_t*) &controlPointCharacteristicUuid,
+                                .uuid = &controlPointCharacteristicUuid.u,
                                 .access_cb = DfuServiceCallback,
                                 .arg = this,
                                 .flags = BLE_GATT_CHR_F_WRITE | BLE_GATT_CHR_F_NOTIFY,
                                 .val_handle = nullptr,
                               },
                               {
-                                .uuid = (ble_uuid_t*) &revisionCharacteristicUuid,
+                                .uuid = &revisionCharacteristicUuid.u,
                                 .access_cb = DfuServiceCallback,
                                 .arg = this,
                                 .flags = BLE_GATT_CHR_F_READ,
@@ -60,7 +60,7 @@ DfuService::DfuService(Pinetime::System::SystemTask& systemTask,
     serviceDefinition {
       {/* Device Information Service */
        .type = BLE_GATT_SVC_TYPE_PRIMARY,
-       .uuid = (ble_uuid_t*) &serviceUuid,
+       .uuid = &serviceUuid.u,
        .characteristics = characteristicDefinition},
       {0},
     } {
@@ -81,9 +81,9 @@ int DfuService::OnServiceData(uint16_t connectionHandle, uint16_t attributeHandl
     xTimerStart(timeoutTimer, 0);
   }
 
-  ble_gatts_find_chr((ble_uuid_t*) &serviceUuid, (ble_uuid_t*) &packetCharacteristicUuid, nullptr, &packetCharacteristicHandle);
-  ble_gatts_find_chr((ble_uuid_t*) &serviceUuid, (ble_uuid_t*) &controlPointCharacteristicUuid, nullptr, &controlPointCharacteristicHandle);
-  ble_gatts_find_chr((ble_uuid_t*) &serviceUuid, (ble_uuid_t*) &revisionCharacteristicUuid, nullptr, &revisionCharacteristicHandle);
+  ble_gatts_find_chr(&serviceUuid.u, &packetCharacteristicUuid.u, nullptr, &packetCharacteristicHandle);
+  ble_gatts_find_chr(&serviceUuid.u, &controlPointCharacteristicUuid.u, nullptr, &controlPointCharacteristicHandle);
+  ble_gatts_find_chr(&serviceUuid.u, &revisionCharacteristicUuid.u, nullptr, &revisionCharacteristicHandle);
 
   if (attributeHandle == packetCharacteristicHandle) {
     if (context->op == BLE_GATT_ACCESS_OP_WRITE_CHR)
@@ -164,10 +164,10 @@ int DfuService::WritePacketHandler(uint16_t connectionHandle, os_mbuf* om) {
 
       if ((nbPacketReceived % nbPacketsToNotify) == 0 && bytesReceived != applicationSize) {
         uint8_t data[5] {static_cast<uint8_t>(Opcodes::PacketReceiptNotification),
-                         (uint8_t) (bytesReceived & 0x000000FFu),
-                         (uint8_t) (bytesReceived >> 8u),
-                         (uint8_t) (bytesReceived >> 16u),
-                         (uint8_t) (bytesReceived >> 24u)};
+                         (uint8_t)(bytesReceived & 0x000000FFu),
+                         (uint8_t)(bytesReceived >> 8u),
+                         (uint8_t)(bytesReceived >> 16u),
+                         (uint8_t)(bytesReceived >> 24u)};
         NRF_LOG_INFO("[DFU] -> Send packet notification: %d bytes received", bytesReceived);
         notificationManager.Send(connectionHandle, controlPointCharacteristicHandle, data, 5);
       }
@@ -422,9 +422,9 @@ uint16_t DfuService::DfuImage::ComputeCrc(uint8_t const* p_data, uint32_t size,
   uint16_t crc = (p_crc == NULL) ? 0xFFFF : *p_crc;
 
   for (uint32_t i = 0; i < size; i++) {
-    crc = (uint8_t) (crc >> 8) | (crc << 8);
+    crc = (uint8_t)(crc >> 8) | (crc << 8);
     crc ^= p_data[i];
-    crc ^= (uint8_t) (crc & 0xFF) >> 4;
+    crc ^= (uint8_t)(crc & 0xFF) >> 4;
     crc ^= (crc << 8) << 4;
     crc ^= ((crc & 0xFF) << 4) << 1;
   }
diff --git a/src/components/ble/HeartRateService.cpp b/src/components/ble/HeartRateService.cpp
index c556566b..5b00f492 100644
--- a/src/components/ble/HeartRateService.cpp
+++ b/src/components/ble/HeartRateService.cpp
@@ -18,7 +18,7 @@ namespace {
 HeartRateService::HeartRateService(Pinetime::System::SystemTask& system, Controllers::HeartRateController& heartRateController)
   : system {system},
     heartRateController {heartRateController},
-    characteristicDefinition {{.uuid = (ble_uuid_t*) &heartRateMeasurementUuid,
+    characteristicDefinition {{.uuid = &heartRateMeasurementUuid.u,
                                .access_cb = HeartRateServiceServiceCallback,
                                .arg = this,
                                .flags = BLE_GATT_CHR_F_READ | BLE_GATT_CHR_F_NOTIFY,
@@ -27,7 +27,7 @@ HeartRateService::HeartRateService(Pinetime::System::SystemTask& system, Control
     serviceDefinition {
       {/* Device Information Service */
        .type = BLE_GATT_SVC_TYPE_PRIMARY,
-       .uuid = (ble_uuid_t*) &heartRateServiceUuid,
+       .uuid = &heartRateServiceUuid.u,
        .characteristics = characteristicDefinition},
       {0},
     } {
diff --git a/src/components/ble/ImmediateAlertService.cpp b/src/components/ble/ImmediateAlertService.cpp
index 820d3b6e..17ed1a96 100644
--- a/src/components/ble/ImmediateAlertService.cpp
+++ b/src/components/ble/ImmediateAlertService.cpp
@@ -32,7 +32,7 @@ ImmediateAlertService::ImmediateAlertService(Pinetime::System::SystemTask& syste
                                              Pinetime::Controllers::NotificationManager& notificationManager)
   : systemTask {systemTask},
     notificationManager {notificationManager},
-    characteristicDefinition {{.uuid = (ble_uuid_t*) &alertLevelUuid,
+    characteristicDefinition {{.uuid = &alertLevelUuid.u,
                                .access_cb = AlertLevelCallback,
                                .arg = this,
                                .flags = BLE_GATT_CHR_F_WRITE_NO_RSP,
@@ -41,7 +41,7 @@ ImmediateAlertService::ImmediateAlertService(Pinetime::System::SystemTask& syste
     serviceDefinition {
       {/* Device Information Service */
        .type = BLE_GATT_SVC_TYPE_PRIMARY,
-       .uuid = (ble_uuid_t*) &immediateAlertServiceUuid,
+       .uuid = &immediateAlertServiceUuid.u,
        .characteristics = characteristicDefinition},
       {0},
     } {
@@ -72,4 +72,4 @@ int ImmediateAlertService::OnAlertLevelChanged(uint16_t connectionHandle, uint16
   }
 
   return 0;
-}
\ No newline at end of file
+}
diff --git a/src/components/ble/NavigationService.cpp b/src/components/ble/NavigationService.cpp
index e1c20bf1..b49148d2 100644
--- a/src/components/ble/NavigationService.cpp
+++ b/src/components/ble/NavigationService.cpp
@@ -20,54 +20,45 @@
 
 #include "systemtask/SystemTask.h"
 
-int NAVCallback(uint16_t conn_handle, uint16_t attr_handle, struct ble_gatt_access_ctxt* ctxt, void* arg) {
-  auto navService = static_cast<Pinetime::Controllers::NavigationService*>(arg);
-  return navService->OnCommand(conn_handle, attr_handle, ctxt);
-}
-
-Pinetime::Controllers::NavigationService::NavigationService(Pinetime::System::SystemTask& system) : m_system(system) {
-  navUuid.value[14] = navId[0];
-  navUuid.value[15] = navId[1];
+namespace {
+  // 0001yyxx-78fc-48fe-8e23-433b3a1942d0
+  constexpr ble_uuid128_t CharUuid(uint8_t x, uint8_t y) {
+    return ble_uuid128_t {.u = {.type = BLE_UUID_TYPE_128},
+                          .value = {0xd0, 0x42, 0x19, 0x3a, 0x3b, 0x43, 0x23, 0x8e, 0xfe, 0x48, 0xfc, 0x78, x, y, 0x01, 0x00}};
+  }
 
-  navFlagCharUuid.value[12] = navFlagCharId[0];
-  navFlagCharUuid.value[13] = navFlagCharId[1];
-  navFlagCharUuid.value[14] = navId[0];
-  navFlagCharUuid.value[15] = navId[1];
+  // 00010000-78fc-48fe-8e23-433b3a1942d0
+  constexpr ble_uuid128_t BaseUuid() {
+    return CharUuid(0x00, 0x00);
+  }
 
-  navNarrativeCharUuid.value[12] = navNarrativeCharId[0];
-  navNarrativeCharUuid.value[13] = navNarrativeCharId[1];
-  navNarrativeCharUuid.value[14] = navId[0];
-  navNarrativeCharUuid.value[15] = navId[1];
+  constexpr ble_uuid128_t navUuid {BaseUuid()};
 
-  navManDistCharUuid.value[12] = navManDistCharId[0];
-  navManDistCharUuid.value[13] = navManDistCharId[1];
-  navManDistCharUuid.value[14] = navId[0];
-  navManDistCharUuid.value[15] = navId[1];
+  constexpr ble_uuid128_t navFlagCharUuid {CharUuid(0x01, 0x00)};
+  constexpr ble_uuid128_t navNarrativeCharUuid {CharUuid(0x02, 0x00)};
+  constexpr ble_uuid128_t navManDistCharUuid {CharUuid(0x03, 0x00)};
+  constexpr ble_uuid128_t navProgressCharUuid {CharUuid(0x04, 0x00)};
 
-  navProgressCharUuid.value[12] = navProgressCharId[0];
-  navProgressCharUuid.value[13] = navProgressCharId[1];
-  navProgressCharUuid.value[14] = navId[0];
-  navProgressCharUuid.value[15] = navId[1];
+  int NAVCallback(uint16_t conn_handle, uint16_t attr_handle, struct ble_gatt_access_ctxt* ctxt, void* arg) {
+    auto navService = static_cast<Pinetime::Controllers::NavigationService*>(arg);
+    return navService->OnCommand(conn_handle, attr_handle, ctxt);
+  }
+} // namespace
 
+Pinetime::Controllers::NavigationService::NavigationService(Pinetime::System::SystemTask& system) : m_system(system) {
   characteristicDefinition[0] = {
-    .uuid = (ble_uuid_t*) (&navFlagCharUuid), .access_cb = NAVCallback, .arg = this, .flags = BLE_GATT_CHR_F_WRITE | BLE_GATT_CHR_F_READ};
-
-  characteristicDefinition[1] = {.uuid = (ble_uuid_t*) (&navNarrativeCharUuid),
-                                 .access_cb = NAVCallback,
-                                 .arg = this,
-                                 .flags = BLE_GATT_CHR_F_WRITE | BLE_GATT_CHR_F_READ};
-  characteristicDefinition[2] = {.uuid = (ble_uuid_t*) (&navManDistCharUuid),
-                                 .access_cb = NAVCallback,
-                                 .arg = this,
-                                 .flags = BLE_GATT_CHR_F_WRITE | BLE_GATT_CHR_F_READ};
-  characteristicDefinition[3] = {.uuid = (ble_uuid_t*) (&navProgressCharUuid),
-                                 .access_cb = NAVCallback,
-                                 .arg = this,
-                                 .flags = BLE_GATT_CHR_F_WRITE | BLE_GATT_CHR_F_READ};
+    .uuid = &navFlagCharUuid.u, .access_cb = NAVCallback, .arg = this, .flags = BLE_GATT_CHR_F_WRITE | BLE_GATT_CHR_F_READ};
+
+  characteristicDefinition[1] = {
+    .uuid = &navNarrativeCharUuid.u, .access_cb = NAVCallback, .arg = this, .flags = BLE_GATT_CHR_F_WRITE | BLE_GATT_CHR_F_READ};
+  characteristicDefinition[2] = {
+    .uuid = &navManDistCharUuid.u, .access_cb = NAVCallback, .arg = this, .flags = BLE_GATT_CHR_F_WRITE | BLE_GATT_CHR_F_READ};
+  characteristicDefinition[3] = {
+    .uuid = &navProgressCharUuid.u, .access_cb = NAVCallback, .arg = this, .flags = BLE_GATT_CHR_F_WRITE | BLE_GATT_CHR_F_READ};
 
   characteristicDefinition[4] = {0};
 
-  serviceDefinition[0] = {.type = BLE_GATT_SVC_TYPE_PRIMARY, .uuid = (ble_uuid_t*) &navUuid, .characteristics = characteristicDefinition};
+  serviceDefinition[0] = {.type = BLE_GATT_SVC_TYPE_PRIMARY, .uuid = &navUuid.u, .characteristics = characteristicDefinition};
   serviceDefinition[1] = {0};
 
   m_progress = 0;
@@ -90,13 +81,13 @@ int Pinetime::Controllers::NavigationService::OnCommand(uint16_t conn_handle, ui
     data[notifSize] = '\0';
     os_mbuf_copydata(ctxt->om, 0, notifSize, data);
     char* s = (char*) &data[0];
-    if (ble_uuid_cmp(ctxt->chr->uuid, (ble_uuid_t*) &navFlagCharUuid) == 0) {
+    if (ble_uuid_cmp(ctxt->chr->uuid, &navFlagCharUuid.u) == 0) {
       m_flag = s;
-    } else if (ble_uuid_cmp(ctxt->chr->uuid, (ble_uuid_t*) &navNarrativeCharUuid) == 0) {
+    } else if (ble_uuid_cmp(ctxt->chr->uuid, &navNarrativeCharUuid.u) == 0) {
       m_narrative = s;
-    } else if (ble_uuid_cmp(ctxt->chr->uuid, (ble_uuid_t*) &navManDistCharUuid) == 0) {
+    } else if (ble_uuid_cmp(ctxt->chr->uuid, &navManDistCharUuid.u) == 0) {
       m_manDist = s;
-    } else if (ble_uuid_cmp(ctxt->chr->uuid, (ble_uuid_t*) &navProgressCharUuid) == 0) {
+    } else if (ble_uuid_cmp(ctxt->chr->uuid, &navProgressCharUuid.u) == 0) {
       m_progress = data[0];
     }
   }
diff --git a/src/components/ble/NavigationService.h b/src/components/ble/NavigationService.h
index 5aab263c..c0c77f35 100644
--- a/src/components/ble/NavigationService.h
+++ b/src/components/ble/NavigationService.h
@@ -26,10 +26,6 @@
 #undef max
 #undef min
 
-// c7e60000-78fc-48fe-8e23-433b3a1942d0
-#define NAVIGATION_SERVICE_UUID_BASE                                                                                                       \
-  { 0xd0, 0x42, 0x19, 0x3a, 0x3b, 0x43, 0x23, 0x8e, 0xfe, 0x48, 0xfc, 0x78, 0x00, 0x00, 0x00, 0x00 }
-
 namespace Pinetime {
   namespace System {
     class SystemTask;
@@ -53,19 +49,6 @@ namespace Pinetime {
       int getProgress();
 
     private:
-      static constexpr uint8_t navId[2] = {0x01, 0x00};
-      static constexpr uint8_t navFlagCharId[2] = {0x01, 0x00};
-      static constexpr uint8_t navNarrativeCharId[2] = {0x02, 0x00};
-      static constexpr uint8_t navManDistCharId[2] = {0x03, 0x00};
-      static constexpr uint8_t navProgressCharId[2] = {0x04, 0x00};
-
-      ble_uuid128_t navUuid {.u = {.type = BLE_UUID_TYPE_128}, .value = NAVIGATION_SERVICE_UUID_BASE};
-
-      ble_uuid128_t navFlagCharUuid {.u = {.type = BLE_UUID_TYPE_128}, .value = NAVIGATION_SERVICE_UUID_BASE};
-      ble_uuid128_t navNarrativeCharUuid {.u = {.type = BLE_UUID_TYPE_128}, .value = NAVIGATION_SERVICE_UUID_BASE};
-      ble_uuid128_t navManDistCharUuid {.u = {.type = BLE_UUID_TYPE_128}, .value = NAVIGATION_SERVICE_UUID_BASE};
-      ble_uuid128_t navProgressCharUuid {.u = {.type = BLE_UUID_TYPE_128}, .value = NAVIGATION_SERVICE_UUID_BASE};
-
       struct ble_gatt_chr_def characteristicDefinition[5];
       struct ble_gatt_svc_def serviceDefinition[2];
 
diff --git a/src/components/datetime/DateTimeController.cpp b/src/components/datetime/DateTimeController.cpp
index 0756d38d..e9c5d870 100644
--- a/src/components/datetime/DateTimeController.cpp
+++ b/src/components/datetime/DateTimeController.cpp
@@ -5,6 +5,12 @@
 
 using namespace Pinetime::Controllers;
 
+namespace {
+  char const* DaysStringShort[] = {"--", "MON", "TUE", "WED", "THU", "FRI", "SAT", "SUN"};
+  char const* MonthsString[] = {"--", "JAN", "FEB", "MAR", "APR", "MAY", "JUN", "JUL", "AUG", "SEP", "OCT", "NOV", "DEC"};
+  char const* MonthsStringLow[] = {"--", "Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"};
+}
+
 void DateTime::SetCurrentTime(std::chrono::time_point<std::chrono::system_clock, std::chrono::nanoseconds> t) {
   this->currentDateTime = t;
   UpdateTime(previousSystickCounter); // Update internal state without updating the time
@@ -80,48 +86,18 @@ void DateTime::UpdateTime(uint32_t systickCounter) {
 }
 
 const char* DateTime::MonthShortToString() {
-  return DateTime::MonthsString[static_cast<uint8_t>(month)];
-}
-
-const char* DateTime::MonthShortToStringLow() {
-  return DateTime::MonthsStringLow[static_cast<uint8_t>(month)];
-}
-
-const char* DateTime::MonthsToStringLow() {
-  return DateTime::MonthsLow[static_cast<uint8_t>(month)];
-}
-
-const char* DateTime::DayOfWeekToString() {
-  return DateTime::DaysString[static_cast<uint8_t>(dayOfWeek)];
+  return MonthsString[static_cast<uint8_t>(month)];
 }
 
 const char* DateTime::DayOfWeekShortToString() {
-  return DateTime::DaysStringShort[static_cast<uint8_t>(dayOfWeek)];
+  return DaysStringShort[static_cast<uint8_t>(dayOfWeek)];
 }
 
-const char* DateTime::DayOfWeekToStringLow() {
-  return DateTime::DaysStringLow[static_cast<uint8_t>(dayOfWeek)];
-}
-
-const char* DateTime::DayOfWeekShortToStringLow() {
-  return DateTime::DaysStringShortLow[static_cast<uint8_t>(dayOfWeek)];
+const char* DateTime::MonthShortToStringLow(Months month) {
+  return MonthsStringLow[static_cast<uint8_t>(month)];
 }
 
 void DateTime::Register(Pinetime::System::SystemTask* systemTask) {
   this->systemTask = systemTask;
 }
 
-char const* DateTime::DaysStringLow[] = {"--", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday", "Sunday"};
-
-char const* DateTime::DaysStringShortLow[] = {"--", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat", "Sun"};
-
-char const* DateTime::DaysStringShort[] = {"--", "MON", "TUE", "WED", "THU", "FRI", "SAT", "SUN"};
-
-char const* DateTime::DaysString[] = {"--", "MONDAY", "TUESDAY", "WEDNESDAY", "THURSDAY", "FRIDAY", "SATURDAY", "SUNDAY"};
-
-char const* DateTime::MonthsString[] = {"--", "JAN", "FEB", "MAR", "APR", "MAY", "JUN", "JUL", "AUG", "SEP", "OCT", "NOV", "DEC"};
-
-char const* DateTime::MonthsStringLow[] = {"--", "Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"};
-
-char const* DateTime::MonthsLow[] = {
-  "--", "January", "February", "March", "April", "May", "June", "July", "August", "September", "October", "November", "December"};
\ No newline at end of file
diff --git a/src/components/datetime/DateTimeController.h b/src/components/datetime/DateTimeController.h
index 061c303f..77ed68e8 100644
--- a/src/components/datetime/DateTimeController.h
+++ b/src/components/datetime/DateTimeController.h
@@ -59,12 +59,8 @@ namespace Pinetime {
       }
 
       const char* MonthShortToString();
-      const char* MonthShortToStringLow();
-      const char* MonthsToStringLow();
-      const char* DayOfWeekToString();
       const char* DayOfWeekShortToString();
-      const char* DayOfWeekToStringLow();
-      const char* DayOfWeekShortToStringLow();
+      static const char* MonthShortToStringLow(Months month);
 
       std::chrono::time_point<std::chrono::system_clock, std::chrono::nanoseconds> CurrentDateTime() const {
         return currentDateTime;
@@ -91,14 +87,6 @@ namespace Pinetime {
 
       bool isMidnightAlreadyNotified = false;
       System::SystemTask* systemTask = nullptr;
-
-      static char const* DaysString[];
-      static char const* DaysStringShort[];
-      static char const* DaysStringLow[];
-      static char const* DaysStringShortLow[];
-      static char const* MonthsString[];
-      static char const* MonthsStringLow[];
-      static char const* MonthsLow[];
     };
   }
-}
\ No newline at end of file
+}
diff --git a/src/displayapp/Apps.h b/src/displayapp/Apps.h
index 6cc36145..59b45ce2 100644
--- a/src/displayapp/Apps.h
+++ b/src/displayapp/Apps.h
@@ -31,7 +31,10 @@ namespace Pinetime {
       SettingTimeFormat,
       SettingDisplay,
       SettingWakeUp,
-      SettingSteps
+      SettingSteps,
+      SettingSetDate,
+      SettingSetTime,
+      Error,
     };
   }
 }
diff --git a/src/displayapp/DisplayApp.cpp b/src/displayapp/DisplayApp.cpp
index cdfe0b85..b997da3a 100644
--- a/src/displayapp/DisplayApp.cpp
+++ b/src/displayapp/DisplayApp.cpp
@@ -29,6 +29,7 @@
 #include "displayapp/screens/FlashLight.h"
 #include "displayapp/screens/BatteryInfo.h"
 #include "displayapp/screens/Steps.h"
+#include "displayapp/screens/Error.h"
 
 #include "drivers/Cst816s.h"
 #include "drivers/St7789.h"
@@ -43,6 +44,8 @@
 #include "displayapp/screens/settings/SettingWakeUp.h"
 #include "displayapp/screens/settings/SettingDisplay.h"
 #include "displayapp/screens/settings/SettingSteps.h"
+#include "displayapp/screens/settings/SettingSetDate.h"
+#include "displayapp/screens/settings/SettingSetTime.h"
 
 #include "libs/lv_conf.h"
 
@@ -109,11 +112,16 @@ DisplayApp::DisplayApp(Drivers::St7789& lcd,
     touchHandler {touchHandler} {
 }
 
-void DisplayApp::Start() {
+void DisplayApp::Start(System::BootErrors error) {
   msgQueue = xQueueCreate(queueSize, itemSize);
 
-  // Start clock when smartwatch boots
-  LoadApp(Apps::Clock, DisplayApp::FullRefreshDirections::None);
+  bootError = error;
+
+  if (error == System::BootErrors::TouchController) {
+    LoadApp(Apps::Error, DisplayApp::FullRefreshDirections::None);
+  } else {
+    LoadApp(Apps::Clock, DisplayApp::FullRefreshDirections::None);
+  }
 
   if (pdPASS != xTaskCreate(DisplayApp::Process, "displayapp", 800, this, 0, &taskHandle)) {
     APP_ERROR_HANDLER(NRF_ERROR_NO_MEM);
@@ -308,6 +316,11 @@ void DisplayApp::LoadApp(Apps app, DisplayApp::FullRefreshDirections direction)
                                                        motionController);
       break;
 
+    case Apps::Error:
+      currentScreen = std::make_unique<Screens::Error>(this, bootError);
+      ReturnApp(Apps::Clock, FullRefreshDirections::Down, TouchEvents::None);
+      break;
+
     case Apps::FirmwareValidation:
       currentScreen = std::make_unique<Screens::FirmwareValidation>(this, validator);
       ReturnApp(Apps::Settings, FullRefreshDirections::Down, TouchEvents::SwipeDown);
@@ -364,13 +377,21 @@ void DisplayApp::LoadApp(Apps app, DisplayApp::FullRefreshDirections direction)
       currentScreen = std::make_unique<Screens::SettingSteps>(this, settingsController);
       ReturnApp(Apps::Settings, FullRefreshDirections::Down, TouchEvents::SwipeDown);
       break;
+    case Apps::SettingSetDate:
+      currentScreen = std::make_unique<Screens::SettingSetDate>(this, dateTimeController);
+      ReturnApp(Apps::Settings, FullRefreshDirections::Down, TouchEvents::SwipeDown);
+      break;
+    case Apps::SettingSetTime:
+      currentScreen = std::make_unique<Screens::SettingSetTime>(this, dateTimeController);
+      ReturnApp(Apps::Settings, FullRefreshDirections::Down, TouchEvents::SwipeDown);
+      break;
     case Apps::BatteryInfo:
       currentScreen = std::make_unique<Screens::BatteryInfo>(this, batteryController);
       ReturnApp(Apps::Settings, FullRefreshDirections::Down, TouchEvents::SwipeDown);
       break;
     case Apps::SysInfo:
       currentScreen = std::make_unique<Screens::SystemInfo>(
-        this, dateTimeController, batteryController, brightnessController, bleController, watchdog, motionController);
+        this, dateTimeController, batteryController, brightnessController, bleController, watchdog, motionController, touchPanel);
       ReturnApp(Apps::Settings, FullRefreshDirections::Down, TouchEvents::SwipeDown);
       break;
     case Apps::FlashLight:
diff --git a/src/displayapp/DisplayApp.h b/src/displayapp/DisplayApp.h
index 63e898f0..a87cab0b 100644
--- a/src/displayapp/DisplayApp.h
+++ b/src/displayapp/DisplayApp.h
@@ -18,6 +18,7 @@
 #include "touchhandler/TouchHandler.h"
 
 #include "Messages.h"
+#include "BootErrors.h"
 
 namespace Pinetime {
 
@@ -61,7 +62,7 @@ namespace Pinetime {
                  Pinetime::Controllers::TimerController& timerController,
                  Pinetime::Controllers::AlarmController& alarmController,
                  Pinetime::Controllers::TouchHandler& touchHandler);
-      void Start();
+      void Start(System::BootErrors error);
       void PushMessage(Display::Messages msg);
 
       void StartApp(Apps app, DisplayApp::FullRefreshDirections direction);
@@ -116,6 +117,7 @@ namespace Pinetime {
 
       Apps nextApp = Apps::None;
       DisplayApp::FullRefreshDirections nextDirection;
+      System::BootErrors bootError;
     };
   }
 }
diff --git a/src/displayapp/DisplayAppRecovery.h b/src/displayapp/DisplayAppRecovery.h
index 425e0aca..9f5fb130 100644
--- a/src/displayapp/DisplayAppRecovery.h
+++ b/src/displayapp/DisplayAppRecovery.h
@@ -10,6 +10,7 @@
 #include <date/date.h>
 #include <drivers/Watchdog.h>
 #include <components/motor/MotorController.h>
+#include <BootErrors.h>
 #include "TouchEvents.h"
 #include "Apps.h"
 #include "Messages.h"
@@ -58,6 +59,7 @@ namespace Pinetime {
                  Pinetime::Controllers::AlarmController& alarmController,
                  Pinetime::Controllers::TouchHandler& touchHandler);
       void Start();
+      void Start(Pinetime::System::BootErrors){ Start(); };
       void PushMessage(Pinetime::Applications::Display::Messages msg);
       void Register(Pinetime::System::SystemTask* systemTask);
 
diff --git a/src/displayapp/screens/Alarm.cpp b/src/displayapp/screens/Alarm.cpp
index 959cb0b2..6b45a36e 100644
--- a/src/displayapp/screens/Alarm.cpp
+++ b/src/displayapp/screens/Alarm.cpp
@@ -120,10 +120,7 @@ void Alarm::OnButtonEvent(lv_obj_t* obj, lv_event_t event) {
       return;
     }
     if (obj == btnMessage) {
-      lv_obj_del(txtMessage);
-      lv_obj_del(btnMessage);
-      txtMessage = nullptr;
-      btnMessage = nullptr;
+      HideInfo();
       return;
     }
     // If any other button was pressed, disable the alarm
@@ -174,6 +171,14 @@ void Alarm::OnButtonEvent(lv_obj_t* obj, lv_event_t event) {
   }
 }
 
+bool Alarm::OnButtonPushed() {
+  if (txtMessage != nullptr && btnMessage != nullptr) {
+    HideInfo();
+    return true;
+  }
+  return false;
+}
+
 void Alarm::UpdateAlarmTime() {
   lv_label_set_text_fmt(time, "%02d:%02d", alarmHours, alarmMinutes);
   alarmController.SetAlarmTime(alarmHours, alarmMinutes);
@@ -224,6 +229,12 @@ void Alarm::ShowInfo() {
   }
 }
 
+void Alarm::HideInfo() {
+  lv_obj_del(btnMessage);
+  txtMessage = nullptr;
+  btnMessage = nullptr;
+}
+
 void Alarm::SetRecurButtonState() {
   using Pinetime::Controllers::AlarmController;
   switch (alarmController.Recurrence()) {
diff --git a/src/displayapp/screens/Alarm.h b/src/displayapp/screens/Alarm.h
index abf97eba..32a14d2f 100644
--- a/src/displayapp/screens/Alarm.h
+++ b/src/displayapp/screens/Alarm.h
@@ -31,6 +31,7 @@ namespace Pinetime {
         ~Alarm() override;
         void SetAlerting();
         void OnButtonEvent(lv_obj_t* obj, lv_event_t event);
+        bool OnButtonPushed() override;
 
       private:
         bool running;
@@ -46,6 +47,7 @@ namespace Pinetime {
         void SetRecurButtonState();
         void SetAlarm();
         void ShowInfo();
+        void HideInfo();
         void ToggleRecurrence();
         void UpdateAlarmTime();
       };
diff --git a/src/displayapp/screens/Error.cpp b/src/displayapp/screens/Error.cpp
new file mode 100644
index 00000000..75946aba
--- /dev/null
+++ b/src/displayapp/screens/Error.cpp
@@ -0,0 +1,50 @@
+#include "Error.h"
+
+using namespace Pinetime::Applications::Screens;
+
+namespace {
+  void ButtonEventCallback(lv_obj_t* obj, lv_event_t /*event*/) {
+    auto* errorScreen = static_cast<Error*>(obj->user_data);
+    errorScreen->ButtonEventHandler();
+  }
+}
+
+Error::Error(Pinetime::Applications::DisplayApp* app, System::BootErrors error)
+  : Screen(app) {
+
+  lv_obj_t* warningLabel = lv_label_create(lv_scr_act(), nullptr);
+  lv_obj_set_style_local_text_color(warningLabel, LV_LABEL_PART_MAIN, LV_STATE_DEFAULT, LV_COLOR_ORANGE);
+  lv_label_set_text_static(warningLabel, "Warning");
+  lv_obj_align(warningLabel, nullptr, LV_ALIGN_IN_TOP_MID, 0, 0);
+
+  lv_obj_t* causeLabel = lv_label_create(lv_scr_act(), nullptr);
+  lv_label_set_long_mode(causeLabel, LV_LABEL_LONG_BREAK);
+  lv_obj_set_width(causeLabel, LV_HOR_RES);
+  lv_obj_align(causeLabel, warningLabel, LV_ALIGN_OUT_BOTTOM_MID, 0, 0);
+
+  if (error == System::BootErrors::TouchController) {
+    lv_label_set_text_static(causeLabel, "Touch controller error detected.");
+  }
+
+  lv_obj_t* tipLabel = lv_label_create(lv_scr_act(), nullptr);
+  lv_label_set_long_mode(tipLabel, LV_LABEL_LONG_BREAK);
+  lv_obj_set_width(tipLabel, LV_HOR_RES);
+  lv_label_set_text_static(tipLabel, "If you encounter problems and your device is under warranty, contact the devices seller.");
+  lv_obj_align(tipLabel, causeLabel, LV_ALIGN_OUT_BOTTOM_MID, 0, 0);
+
+  btnOk = lv_btn_create(lv_scr_act(), nullptr);
+  btnOk->user_data = this;
+  lv_obj_set_event_cb(btnOk, ButtonEventCallback);
+  lv_obj_set_size(btnOk, LV_HOR_RES, 50);
+  lv_obj_align(btnOk, lv_scr_act(), LV_ALIGN_IN_BOTTOM_MID, 0, 0);
+  lv_obj_set_style_local_value_str(btnOk, LV_BTN_PART_MAIN, LV_STATE_DEFAULT, "Proceed");
+  lv_obj_set_style_local_bg_color(btnOk, LV_BTN_PART_MAIN, LV_STATE_DEFAULT, LV_COLOR_ORANGE);
+}
+
+void Error::ButtonEventHandler() {
+  running = false;
+}
+
+Error::~Error() {
+  lv_obj_clean(lv_scr_act());
+}
diff --git a/src/displayapp/screens/Error.h b/src/displayapp/screens/Error.h
new file mode 100644
index 00000000..20dde7ee
--- /dev/null
+++ b/src/displayapp/screens/Error.h
@@ -0,0 +1,21 @@
+#pragma once
+
+#include "Screen.h"
+#include "BootErrors.h"
+#include <lvgl/lvgl.h>
+
+namespace Pinetime {
+  namespace Applications {
+    namespace Screens {
+      class Error : public Screen {
+      public:
+        Error(DisplayApp* app, System::BootErrors error);
+        ~Error() override;
+
+        void ButtonEventHandler();
+      private:
+        lv_obj_t* btnOk;
+      };
+    }
+  }
+}
diff --git a/src/displayapp/screens/Paddle.cpp b/src/displayapp/screens/Paddle.cpp
index 3b6d60e3..26c2368b 100644
--- a/src/displayapp/screens/Paddle.cpp
+++ b/src/displayapp/screens/Paddle.cpp
@@ -47,8 +47,8 @@ void Paddle::Refresh() {
     dy *= -1;
   }
 
-  // checks if it has touched the side (left side)
-  if (ballX >= LV_VER_RES - ballSize - 1) {
+  // checks if it has touched the side (right side)
+  if (ballX >= LV_HOR_RES - ballSize - 1) {
     dx *= -1;
   }
 
diff --git a/src/displayapp/screens/PineTimeStyle.cpp b/src/displayapp/screens/PineTimeStyle.cpp
index 6dd8f485..6d4855d2 100644
--- a/src/displayapp/screens/PineTimeStyle.cpp
+++ b/src/displayapp/screens/PineTimeStyle.cpp
@@ -1,5 +1,5 @@
 /*
- * This file is part of the Infinitime distribution (https://github.com/JF002/Infinitime).
+ * This file is part of the Infinitime distribution (https://github.com/InfiniTimeOrg/Infinitime).
  * Copyright (c) 2021 Kieran Cawthray.
  *
  * This program is free software: you can redistribute it and/or modify
diff --git a/src/displayapp/screens/SystemInfo.cpp b/src/displayapp/screens/SystemInfo.cpp
index b7a4fc60..343b72bf 100644
--- a/src/displayapp/screens/SystemInfo.cpp
+++ b/src/displayapp/screens/SystemInfo.cpp
@@ -33,7 +33,8 @@ SystemInfo::SystemInfo(Pinetime::Applications::DisplayApp* app,
                        Pinetime::Controllers::BrightnessController& brightnessController,
                        Pinetime::Controllers::Ble& bleController,
                        Pinetime::Drivers::WatchdogView& watchdog,
-                       Pinetime::Controllers::MotionController& motionController)
+                       Pinetime::Controllers::MotionController& motionController,
+                       Pinetime::Drivers::Cst816S& touchPanel)
   : Screen(app),
     dateTimeController {dateTimeController},
     batteryController {batteryController},
@@ -41,6 +42,7 @@ SystemInfo::SystemInfo(Pinetime::Applications::DisplayApp* app,
     bleController {bleController},
     watchdog {watchdog},
     motionController{motionController},
+    touchPanel{touchPanel},
     screens {app,
              0,
              {[this]() -> std::unique_ptr<Screen> {
@@ -141,7 +143,8 @@ std::unique_ptr<Screen> SystemInfo::CreateScreen2() {
                         "#444444 Battery# %d%%/%03imV\n"
                         "#444444 Backlight# %s\n"
                         "#444444 Last reset# %s\n"
-                        "#444444 Accel.# %s\n",
+                        "#444444 Accel.# %s\n"
+                        "#444444 Touch.# %x.%x.%x\n",
                         dateTimeController.Day(),
                         static_cast<uint8_t>(dateTimeController.Month()),
                         dateTimeController.Year(),
@@ -156,7 +159,10 @@ std::unique_ptr<Screen> SystemInfo::CreateScreen2() {
                         batteryController.Voltage(),
                         brightnessController.ToString(),
                         resetReason,
-                        ToString(motionController.DeviceType()));
+                        ToString(motionController.DeviceType()),
+                        touchPanel.GetChipId(),
+                        touchPanel.GetVendorId(),
+                        touchPanel.GetFwVersion());
   lv_obj_align(label, lv_scr_act(), LV_ALIGN_CENTER, 0, 0);
   return std::make_unique<Screens::Label>(1, 5, app, label);
 }
@@ -200,11 +206,14 @@ bool SystemInfo::sortById(const TaskStatus_t& lhs, const TaskStatus_t& rhs) {
 }
 
 std::unique_ptr<Screen> SystemInfo::CreateScreen4() {
-  TaskStatus_t tasksStatus[10];
+  static constexpr uint8_t maxTaskCount = 9;
+  TaskStatus_t tasksStatus[maxTaskCount];
+
   lv_obj_t* infoTask = lv_table_create(lv_scr_act(), NULL);
   lv_table_set_col_cnt(infoTask, 4);
-  lv_table_set_row_cnt(infoTask, 8);
-  lv_obj_set_pos(infoTask, 0, 10);
+  lv_table_set_row_cnt(infoTask, maxTaskCount + 1);
+  lv_obj_set_style_local_pad_all(infoTask, LV_TABLE_PART_CELL1, LV_STATE_DEFAULT, 0);
+  lv_obj_set_style_local_border_color(infoTask, LV_TABLE_PART_CELL1, LV_STATE_DEFAULT, LV_COLOR_GRAY);
 
   lv_table_set_cell_value(infoTask, 0, 0, "#");
   lv_table_set_col_width(infoTask, 0, 30);
@@ -215,9 +224,9 @@ std::unique_ptr<Screen> SystemInfo::CreateScreen4() {
   lv_table_set_cell_value(infoTask, 0, 3, "Free");
   lv_table_set_col_width(infoTask, 3, 90);
 
-  auto nb = uxTaskGetSystemState(tasksStatus, sizeof(tasksStatus) / sizeof(tasksStatus[0]), nullptr);
+  auto nb = uxTaskGetSystemState(tasksStatus, maxTaskCount, nullptr);
   std::sort(tasksStatus, tasksStatus + nb, sortById);
-  for (uint8_t i = 0; i < nb && i < 7; i++) {
+  for (uint8_t i = 0; i < nb && i < maxTaskCount; i++) {
 
     lv_table_set_cell_value(infoTask, i + 1, 0, std::to_string(tasksStatus[i].xTaskNumber).c_str());
     char state[2] = {0};
@@ -261,7 +270,8 @@ std::unique_ptr<Screen> SystemInfo::CreateScreen5() {
                            "Public License v3\n"
                            "#444444 Source code#\n"
                            "#FFFF00 https://github.com/#\n"
-                           "#FFFF00 JF002/InfiniTime#");
+                           "#FFFF00 InfiniTimeOrg/#\n"
+                           "#FFFF00 InfiniTime#");
   lv_label_set_align(label, LV_LABEL_ALIGN_CENTER);
   lv_obj_align(label, lv_scr_act(), LV_ALIGN_CENTER, 0, 0);
   return std::make_unique<Screens::Label>(4, 5, app, label);
diff --git a/src/displayapp/screens/SystemInfo.h b/src/displayapp/screens/SystemInfo.h
index 5eb7054d..bfcc3aa4 100644
--- a/src/displayapp/screens/SystemInfo.h
+++ b/src/displayapp/screens/SystemInfo.h
@@ -28,7 +28,8 @@ namespace Pinetime {
                             Pinetime::Controllers::BrightnessController& brightnessController,
                             Pinetime::Controllers::Ble& bleController,
                             Pinetime::Drivers::WatchdogView& watchdog,
-                            Pinetime::Controllers::MotionController& motionController);
+                            Pinetime::Controllers::MotionController& motionController,
+                            Pinetime::Drivers::Cst816S& touchPanel);
         ~SystemInfo() override;
         bool OnTouchEvent(TouchEvents event) override;
 
@@ -39,6 +40,7 @@ namespace Pinetime {
         Pinetime::Controllers::Ble& bleController;
         Pinetime::Drivers::WatchdogView& watchdog;
         Pinetime::Controllers::MotionController& motionController;
+        Pinetime::Drivers::Cst816S& touchPanel;
 
         ScreenList<5> screens;
 
diff --git a/src/displayapp/screens/settings/SettingSetDate.cpp b/src/displayapp/screens/settings/SettingSetDate.cpp
new file mode 100644
index 00000000..ba3413ef
--- /dev/null
+++ b/src/displayapp/screens/settings/SettingSetDate.cpp
@@ -0,0 +1,198 @@
+#include "SettingSetDate.h"
+#include <lvgl/lvgl.h>
+#include <hal/nrf_rtc.h>
+#include <nrf_log.h>
+#include "displayapp/DisplayApp.h"
+#include "displayapp/screens/Symbols.h"
+
+using namespace Pinetime::Applications::Screens;
+
+namespace {
+  constexpr int16_t POS_X_DAY = -72;
+  constexpr int16_t POS_X_MONTH = 0;
+  constexpr int16_t POS_X_YEAR = 72;
+  constexpr int16_t POS_Y_PLUS = -50;
+  constexpr int16_t POS_Y_TEXT = -6;
+  constexpr int16_t POS_Y_MINUS = 40;
+
+  void event_handler(lv_obj_t * obj, lv_event_t event) {
+    auto* screen = static_cast<SettingSetDate *>(obj->user_data);
+    screen->HandleButtonPress(obj, event);
+  }
+}
+
+SettingSetDate::SettingSetDate(Pinetime::Applications::DisplayApp *app, Pinetime::Controllers::DateTime &dateTimeController) :
+  Screen(app),
+  dateTimeController {dateTimeController} {
+  lv_obj_t * title = lv_label_create(lv_scr_act(), nullptr);
+  lv_label_set_text_static(title, "Set current date");
+  lv_label_set_align(title, LV_LABEL_ALIGN_CENTER);
+  lv_obj_align(title, lv_scr_act(), LV_ALIGN_IN_TOP_MID, 15, 15);
+
+  lv_obj_t * icon = lv_label_create(lv_scr_act(), nullptr);
+  lv_obj_set_style_local_text_color(icon, LV_LABEL_PART_MAIN, LV_STATE_DEFAULT, LV_COLOR_ORANGE);
+  
+  lv_label_set_text_static(icon, Symbols::clock);
+  lv_label_set_align(icon, LV_LABEL_ALIGN_CENTER);
+  lv_obj_align(icon, title, LV_ALIGN_OUT_LEFT_MID, -10, 0);
+
+  dayValue = static_cast<int>(dateTimeController.Day());
+  lblDay = lv_label_create(lv_scr_act(), nullptr);
+  lv_label_set_text_fmt(lblDay, "%d", dayValue);
+  lv_label_set_align(lblDay, LV_LABEL_ALIGN_CENTER);
+  lv_obj_align(lblDay, lv_scr_act(), LV_ALIGN_CENTER, POS_X_DAY, POS_Y_TEXT);
+  lv_obj_set_auto_realign(lblDay, true);
+
+  monthValue = static_cast<int>(dateTimeController.Month());
+  lblMonth = lv_label_create(lv_scr_act(), nullptr);
+  UpdateMonthLabel();
+  lv_label_set_align(lblMonth, LV_LABEL_ALIGN_CENTER);
+  lv_obj_align(lblMonth, lv_scr_act(), LV_ALIGN_CENTER, POS_X_MONTH, POS_Y_TEXT);
+  lv_obj_set_auto_realign(lblMonth, true);
+
+  yearValue = static_cast<int>(dateTimeController.Year());
+  if (yearValue < 2021)
+    yearValue = 2021;
+  lblYear = lv_label_create(lv_scr_act(), nullptr);
+  lv_label_set_text_fmt(lblYear, "%d", yearValue);
+  lv_label_set_align(lblYear, LV_LABEL_ALIGN_CENTER);
+  lv_obj_align(lblYear, lv_scr_act(), LV_ALIGN_CENTER, POS_X_YEAR, POS_Y_TEXT);
+  lv_obj_set_auto_realign(lblYear, true);
+
+  btnDayPlus = lv_btn_create(lv_scr_act(), nullptr);
+  btnDayPlus->user_data = this;
+  lv_obj_set_size(btnDayPlus, 50, 40);
+  lv_obj_align(btnDayPlus, lv_scr_act(), LV_ALIGN_CENTER, POS_X_DAY, POS_Y_PLUS);
+  lv_obj_set_style_local_value_str(btnDayPlus, LV_BTN_PART_MAIN, LV_STATE_DEFAULT, "+");
+  lv_obj_set_event_cb(btnDayPlus, event_handler);
+
+  btnDayMinus = lv_btn_create(lv_scr_act(), nullptr);
+  btnDayMinus->user_data = this;
+  lv_obj_set_size(btnDayMinus, 50, 40);
+  lv_obj_align(btnDayMinus, lv_scr_act(), LV_ALIGN_CENTER, POS_X_DAY, POS_Y_MINUS);
+  lv_obj_set_style_local_value_str(btnDayMinus, LV_BTN_PART_MAIN, LV_STATE_DEFAULT, "-");
+  lv_obj_set_event_cb(btnDayMinus, event_handler);
+
+  btnMonthPlus = lv_btn_create(lv_scr_act(), nullptr);
+  btnMonthPlus->user_data = this;
+  lv_obj_set_size(btnMonthPlus, 50, 40);
+  lv_obj_align(btnMonthPlus, lv_scr_act(), LV_ALIGN_CENTER, POS_X_MONTH, POS_Y_PLUS);
+  lv_obj_set_style_local_value_str(btnMonthPlus, LV_BTN_PART_MAIN, LV_STATE_DEFAULT, "+");
+  lv_obj_set_event_cb(btnMonthPlus, event_handler);
+
+  btnMonthMinus = lv_btn_create(lv_scr_act(), nullptr);
+  btnMonthMinus->user_data = this;
+  lv_obj_set_size(btnMonthMinus, 50, 40);
+  lv_obj_align(btnMonthMinus, lv_scr_act(), LV_ALIGN_CENTER, POS_X_MONTH, POS_Y_MINUS);
+  lv_obj_set_style_local_value_str(btnMonthMinus, LV_BTN_PART_MAIN, LV_STATE_DEFAULT, "-");
+  lv_obj_set_event_cb(btnMonthMinus, event_handler);
+
+  btnYearPlus = lv_btn_create(lv_scr_act(), nullptr);
+  btnYearPlus->user_data = this;
+  lv_obj_set_size(btnYearPlus, 50, 40);
+  lv_obj_align(btnYearPlus, lv_scr_act(), LV_ALIGN_CENTER, POS_X_YEAR, POS_Y_PLUS);
+  lv_obj_set_style_local_value_str(btnYearPlus, LV_BTN_PART_MAIN, LV_STATE_DEFAULT, "+");
+  lv_obj_set_event_cb(btnYearPlus, event_handler);
+
+  btnYearMinus = lv_btn_create(lv_scr_act(), nullptr);
+  btnYearMinus->user_data = this;
+  lv_obj_set_size(btnYearMinus, 50, 40);
+  lv_obj_align(btnYearMinus, lv_scr_act(), LV_ALIGN_CENTER, POS_X_YEAR, POS_Y_MINUS);
+  lv_obj_set_style_local_value_str(btnYearMinus, LV_BTN_PART_MAIN, LV_STATE_DEFAULT, "-");
+  lv_obj_set_event_cb(btnYearMinus, event_handler);
+
+  btnSetTime = lv_btn_create(lv_scr_act(), nullptr);
+  btnSetTime->user_data = this;
+  lv_obj_set_size(btnSetTime, 120, 48);
+  lv_obj_align(btnSetTime, lv_scr_act(), LV_ALIGN_IN_BOTTOM_MID, 0, 0);
+  lv_obj_set_style_local_value_str(btnSetTime, LV_BTN_PART_MAIN, LV_STATE_DEFAULT, "Set");
+  lv_obj_set_event_cb(btnSetTime, event_handler);
+}
+
+SettingSetDate::~SettingSetDate() {
+  lv_obj_clean(lv_scr_act());
+}
+
+void SettingSetDate::HandleButtonPress(lv_obj_t *object, lv_event_t event) {
+  if (event != LV_EVENT_CLICKED)
+    return;
+
+  if (object == btnDayPlus) {
+    dayValue++;
+    if (dayValue > MaximumDayOfMonth())
+      dayValue = 1;
+    lv_label_set_text_fmt(lblDay, "%d", dayValue);
+    lv_btn_set_state(btnSetTime, LV_BTN_STATE_RELEASED);
+  } else if (object == btnDayMinus) {
+    dayValue--;
+    if (dayValue < 1)
+      dayValue = MaximumDayOfMonth();
+    lv_label_set_text_fmt(lblDay, "%d", dayValue);
+    lv_btn_set_state(btnSetTime, LV_BTN_STATE_RELEASED);
+  } else if (object == btnMonthPlus) {
+    monthValue++;
+    if (monthValue > 12)
+      monthValue = 1;
+    UpdateMonthLabel();
+    lv_btn_set_state(btnSetTime, LV_BTN_STATE_RELEASED);
+    CheckDay();
+  } else if (object == btnMonthMinus) {
+    monthValue--;
+    if (monthValue < 1)
+      monthValue = 12;
+    UpdateMonthLabel();
+    lv_btn_set_state(btnSetTime, LV_BTN_STATE_RELEASED);
+    CheckDay();
+  } else if (object == btnYearPlus) {
+    yearValue++;
+    lv_label_set_text_fmt(lblYear, "%d", yearValue);
+    lv_btn_set_state(btnSetTime, LV_BTN_STATE_RELEASED);
+    CheckDay();
+  } else if (object == btnYearMinus) {
+    yearValue--;
+    lv_label_set_text_fmt(lblYear, "%d", yearValue);
+    lv_btn_set_state(btnSetTime, LV_BTN_STATE_RELEASED);
+    CheckDay();
+  } else if (object == btnSetTime) {
+    NRF_LOG_INFO("Setting date (manually) to %04d-%02d-%02d", yearValue, monthValue, dayValue);
+    dateTimeController.SetTime(static_cast<uint16_t>(yearValue),
+                               static_cast<uint8_t>(monthValue),
+                               static_cast<uint8_t>(dayValue),
+                               0,
+                               dateTimeController.Hours(),
+                               dateTimeController.Minutes(),
+                               dateTimeController.Seconds(),
+                               nrf_rtc_counter_get(portNRF_RTC_REG));
+    lv_btn_set_state(btnSetTime, LV_BTN_STATE_DISABLED);
+  }
+}
+
+int SettingSetDate::MaximumDayOfMonth() const {
+  switch (monthValue) {
+    case 2:
+      if ((((yearValue % 4) == 0) && ((yearValue % 100) != 0)) || ((yearValue % 400) == 0))
+        return 29;
+      return 28;
+    case 4:
+    case 6:
+    case 9:
+    case 11:
+      return 30;
+    default:
+      return 31;
+  }
+}
+
+void SettingSetDate::CheckDay() {
+  int maxDay = MaximumDayOfMonth();
+  if (dayValue > maxDay) {
+    dayValue = maxDay;
+    lv_label_set_text_fmt(lblDay, "%d", dayValue);
+    lv_obj_align(lblDay, lv_scr_act(), LV_ALIGN_CENTER, POS_X_DAY, POS_Y_TEXT);
+  }
+}
+
+void SettingSetDate::UpdateMonthLabel() {
+  lv_label_set_text_static(
+    lblMonth, Pinetime::Controllers::DateTime::MonthShortToStringLow(static_cast<Pinetime::Controllers::DateTime::Months>(monthValue)));
+}
diff --git a/src/displayapp/screens/settings/SettingSetDate.h b/src/displayapp/screens/settings/SettingSetDate.h
new file mode 100644
index 00000000..477337ff
--- /dev/null
+++ b/src/displayapp/screens/settings/SettingSetDate.h
@@ -0,0 +1,41 @@
+#pragma once
+
+#include <cstdint>
+#include <lvgl/lvgl.h>
+#include "components/datetime/DateTimeController.h"
+#include "displayapp/screens/Screen.h"
+
+namespace Pinetime {
+  namespace Applications {
+    namespace Screens {
+      class SettingSetDate : public Screen{
+        public:
+          SettingSetDate(DisplayApp* app, Pinetime::Controllers::DateTime &dateTimeController);
+          ~SettingSetDate() override;
+
+          void HandleButtonPress(lv_obj_t *object, lv_event_t event);
+         
+        private:
+          Controllers::DateTime& dateTimeController;
+
+          int dayValue;
+          int monthValue;
+          int yearValue;
+          lv_obj_t * lblDay;
+          lv_obj_t * lblMonth;
+          lv_obj_t * lblYear;
+          lv_obj_t * btnDayPlus;
+          lv_obj_t * btnDayMinus;
+          lv_obj_t * btnMonthPlus;
+          lv_obj_t * btnMonthMinus;
+          lv_obj_t * btnYearPlus;
+          lv_obj_t * btnYearMinus;
+          lv_obj_t * btnSetTime;
+
+          int MaximumDayOfMonth() const;
+          void CheckDay();
+          void UpdateMonthLabel();
+      };
+    }
+  }
+}
diff --git a/src/displayapp/screens/settings/SettingSetTime.cpp b/src/displayapp/screens/settings/SettingSetTime.cpp
new file mode 100644
index 00000000..194bf5eb
--- /dev/null
+++ b/src/displayapp/screens/settings/SettingSetTime.cpp
@@ -0,0 +1,154 @@
+#include "SettingSetTime.h"
+#include <lvgl/lvgl.h>
+#include <hal/nrf_rtc.h>
+#include <nrf_log.h>
+#include "displayapp/DisplayApp.h"
+#include "displayapp/screens/Symbols.h"
+
+using namespace Pinetime::Applications::Screens;
+
+namespace {
+  constexpr int16_t POS_X_HOURS = -72;
+  constexpr int16_t POS_X_MINUTES = 0;
+  constexpr int16_t POS_X_SECONDS = 72;
+  constexpr int16_t POS_Y_PLUS = -50;
+  constexpr int16_t POS_Y_TEXT = -6;
+  constexpr int16_t POS_Y_MINUS = 40;
+  constexpr int16_t OFS_Y_COLON = -2;
+
+  void event_handler(lv_obj_t * obj, lv_event_t event) {
+    auto* screen = static_cast<SettingSetTime *>(obj->user_data);
+    screen->HandleButtonPress(obj, event);
+  }
+}
+
+SettingSetTime::SettingSetTime(Pinetime::Applications::DisplayApp *app, Pinetime::Controllers::DateTime &dateTimeController) :
+  Screen(app),
+  dateTimeController {dateTimeController} {
+  lv_obj_t * title = lv_label_create(lv_scr_act(), nullptr);
+  lv_label_set_text_static(title, "Set current time");
+  lv_label_set_align(title, LV_LABEL_ALIGN_CENTER);
+  lv_obj_align(title, lv_scr_act(), LV_ALIGN_IN_TOP_MID, 15, 15);
+
+  lv_obj_t * icon = lv_label_create(lv_scr_act(), nullptr);
+  lv_obj_set_style_local_text_color(icon, LV_LABEL_PART_MAIN, LV_STATE_DEFAULT, LV_COLOR_ORANGE);
+  
+  lv_label_set_text_static(icon, Symbols::clock);
+  lv_label_set_align(icon, LV_LABEL_ALIGN_CENTER);
+  lv_obj_align(icon, title, LV_ALIGN_OUT_LEFT_MID, -10, 0);
+
+  hoursValue = static_cast<int>(dateTimeController.Hours());
+  lblHours = lv_label_create(lv_scr_act(), nullptr);
+  lv_obj_set_style_local_text_font(lblHours, LV_LABEL_PART_MAIN, LV_STATE_DEFAULT, &jetbrains_mono_42);
+  lv_label_set_text_fmt(lblHours, "%02d", hoursValue);
+  lv_label_set_align(lblHours, LV_LABEL_ALIGN_CENTER);
+  lv_obj_align(lblHours, lv_scr_act(), LV_ALIGN_CENTER, POS_X_HOURS, POS_Y_TEXT);
+  lv_obj_set_auto_realign(lblHours, true);
+
+  lv_obj_t * lblColon1 = lv_label_create(lv_scr_act(), nullptr);
+  lv_obj_set_style_local_text_font(lblColon1, LV_LABEL_PART_MAIN, LV_STATE_DEFAULT, &jetbrains_mono_42);
+  lv_label_set_text_static(lblColon1, ":");
+  lv_label_set_align(lblColon1, LV_LABEL_ALIGN_CENTER);
+  lv_obj_align(lblColon1, lv_scr_act(), LV_ALIGN_CENTER, (POS_X_HOURS + POS_X_MINUTES) / 2, POS_Y_TEXT + OFS_Y_COLON);
+
+  minutesValue = static_cast<int>(dateTimeController.Minutes());
+  lblMinutes = lv_label_create(lv_scr_act(), nullptr);
+  lv_obj_set_style_local_text_font(lblMinutes, LV_LABEL_PART_MAIN, LV_STATE_DEFAULT, &jetbrains_mono_42);
+  lv_label_set_text_fmt(lblMinutes, "%02d", minutesValue);
+  lv_label_set_align(lblMinutes, LV_LABEL_ALIGN_CENTER);
+  lv_obj_align(lblMinutes, lv_scr_act(), LV_ALIGN_CENTER, POS_X_MINUTES, POS_Y_TEXT);
+  lv_obj_set_auto_realign(lblMinutes, true);
+
+  lv_obj_t * lblColon2 = lv_label_create(lv_scr_act(), nullptr);
+  lv_obj_set_style_local_text_font(lblColon2, LV_LABEL_PART_MAIN, LV_STATE_DEFAULT, &jetbrains_mono_42);
+  lv_label_set_text_static(lblColon2, ":");
+  lv_label_set_align(lblColon2, LV_LABEL_ALIGN_CENTER);
+  lv_obj_align(lblColon2, lv_scr_act(), LV_ALIGN_CENTER, (POS_X_MINUTES + POS_X_SECONDS) / 2, POS_Y_TEXT + OFS_Y_COLON);
+
+  lv_obj_t * lblSeconds = lv_label_create(lv_scr_act(), nullptr);
+  lv_obj_set_style_local_text_font(lblSeconds, LV_LABEL_PART_MAIN, LV_STATE_DEFAULT, &jetbrains_mono_42);
+  lv_label_set_text_static(lblSeconds, "00");
+  lv_label_set_align(lblSeconds, LV_LABEL_ALIGN_CENTER);
+  lv_obj_align(lblSeconds, lv_scr_act(), LV_ALIGN_CENTER, POS_X_SECONDS, POS_Y_TEXT);
+
+  btnHoursPlus = lv_btn_create(lv_scr_act(), nullptr);
+  btnHoursPlus->user_data = this;
+  lv_obj_set_size(btnHoursPlus, 50, 40);
+  lv_obj_align(btnHoursPlus, lv_scr_act(), LV_ALIGN_CENTER, -72, -50);
+  lv_obj_set_style_local_value_str(btnHoursPlus, LV_BTN_PART_MAIN, LV_STATE_DEFAULT, "+");
+  lv_obj_set_event_cb(btnHoursPlus, event_handler);
+
+  btnHoursMinus = lv_btn_create(lv_scr_act(), nullptr);
+  btnHoursMinus->user_data = this;
+  lv_obj_set_size(btnHoursMinus, 50, 40);
+  lv_obj_align(btnHoursMinus, lv_scr_act(), LV_ALIGN_CENTER, -72, 40);
+  lv_obj_set_style_local_value_str(btnHoursMinus, LV_BTN_PART_MAIN, LV_STATE_DEFAULT, "-");
+  lv_obj_set_event_cb(btnHoursMinus, event_handler);
+
+  btnMinutesPlus = lv_btn_create(lv_scr_act(), nullptr);
+  btnMinutesPlus->user_data = this;
+  lv_obj_set_size(btnMinutesPlus, 50, 40);
+  lv_obj_align(btnMinutesPlus, lv_scr_act(), LV_ALIGN_CENTER, 0, -50);
+  lv_obj_set_style_local_value_str(btnMinutesPlus, LV_BTN_PART_MAIN, LV_STATE_DEFAULT, "+");
+  lv_obj_set_event_cb(btnMinutesPlus, event_handler);
+
+  btnMinutesMinus = lv_btn_create(lv_scr_act(), nullptr);
+  btnMinutesMinus->user_data = this;
+  lv_obj_set_size(btnMinutesMinus, 50, 40);
+  lv_obj_align(btnMinutesMinus, lv_scr_act(), LV_ALIGN_CENTER, 0, 40);
+  lv_obj_set_style_local_value_str(btnMinutesMinus, LV_BTN_PART_MAIN, LV_STATE_DEFAULT, "-");
+  lv_obj_set_event_cb(btnMinutesMinus, event_handler);
+
+  btnSetTime = lv_btn_create(lv_scr_act(), nullptr);
+  btnSetTime->user_data = this;
+  lv_obj_set_size(btnSetTime, 120, 48);
+  lv_obj_align(btnSetTime, lv_scr_act(), LV_ALIGN_IN_BOTTOM_MID, 0, 0);
+  lv_obj_set_style_local_value_str(btnSetTime, LV_BTN_PART_MAIN, LV_STATE_DEFAULT, "Set");
+  lv_obj_set_event_cb(btnSetTime, event_handler);
+}
+
+SettingSetTime::~SettingSetTime() {
+  lv_obj_clean(lv_scr_act());
+}
+
+void SettingSetTime::HandleButtonPress(lv_obj_t *object, lv_event_t event) {
+  if (event != LV_EVENT_CLICKED)
+    return;
+
+  if (object == btnHoursPlus) {
+    hoursValue++;
+    if (hoursValue > 23)
+      hoursValue = 0;
+    lv_label_set_text_fmt(lblHours, "%02d", hoursValue);
+    lv_btn_set_state(btnSetTime, LV_BTN_STATE_RELEASED);
+  } else if (object == btnHoursMinus) {
+    hoursValue--;
+    if (hoursValue < 0)
+      hoursValue = 23;
+    lv_label_set_text_fmt(lblHours, "%02d", hoursValue);
+    lv_btn_set_state(btnSetTime, LV_BTN_STATE_RELEASED);
+  } else if (object == btnMinutesPlus) {
+    minutesValue++;
+    if (minutesValue > 59)
+      minutesValue = 0;
+    lv_label_set_text_fmt(lblMinutes, "%02d", minutesValue);
+    lv_btn_set_state(btnSetTime, LV_BTN_STATE_RELEASED);
+  } else if (object == btnMinutesMinus) {
+    minutesValue--;
+    if (minutesValue < 0)
+      minutesValue = 59;
+    lv_label_set_text_fmt(lblMinutes, "%02d", minutesValue);
+    lv_btn_set_state(btnSetTime, LV_BTN_STATE_RELEASED);
+  } else if (object == btnSetTime) {
+    NRF_LOG_INFO("Setting time (manually) to %02d:%02d:00", hoursValue, minutesValue);
+    dateTimeController.SetTime(dateTimeController.Year(),
+                               static_cast<uint8_t>(dateTimeController.Month()),
+                               dateTimeController.Day(),
+                               static_cast<uint8_t>(dateTimeController.DayOfWeek()),
+                               static_cast<uint8_t>(hoursValue),
+                               static_cast<uint8_t>(minutesValue),
+                               0,
+                               nrf_rtc_counter_get(portNRF_RTC_REG));
+    lv_btn_set_state(btnSetTime, LV_BTN_STATE_DISABLED);
+  }
+}
diff --git a/src/displayapp/screens/settings/SettingSetTime.h b/src/displayapp/screens/settings/SettingSetTime.h
new file mode 100644
index 00000000..8ba41eae
--- /dev/null
+++ b/src/displayapp/screens/settings/SettingSetTime.h
@@ -0,0 +1,33 @@
+#pragma once
+
+#include <cstdint>
+#include <lvgl/lvgl.h>
+#include "components/datetime/DateTimeController.h"
+#include "displayapp/screens/Screen.h"
+
+namespace Pinetime {
+  namespace Applications {
+    namespace Screens {
+      class SettingSetTime : public Screen{
+        public:
+          SettingSetTime(DisplayApp* app, Pinetime::Controllers::DateTime &dateTimeController);
+          ~SettingSetTime() override;
+
+          void HandleButtonPress(lv_obj_t *object, lv_event_t event);
+         
+        private:
+          Controllers::DateTime& dateTimeController;
+
+          int hoursValue;
+          int minutesValue;
+          lv_obj_t * lblHours;
+          lv_obj_t * lblMinutes;
+          lv_obj_t * btnHoursPlus;
+          lv_obj_t * btnHoursMinus;
+          lv_obj_t * btnMinutesPlus;
+          lv_obj_t * btnMinutesMinus;
+          lv_obj_t * btnSetTime;
+      };
+    }
+  }
+}
diff --git a/src/displayapp/screens/settings/Settings.cpp b/src/displayapp/screens/settings/Settings.cpp
index aa422e25..46fa50ab 100644
--- a/src/displayapp/screens/settings/Settings.cpp
+++ b/src/displayapp/screens/settings/Settings.cpp
@@ -47,8 +47,20 @@ std::unique_ptr<Screen> Settings::CreateScreen2() {
   std::array<Screens::List::Applications, 4> applications {{
     {Symbols::shoe, "Steps", Apps::SettingSteps},
     {Symbols::batteryHalf, "Battery", Apps::BatteryInfo},
+    {Symbols::clock, "Set date", Apps::SettingSetDate},
+    {Symbols::clock, "Set time", Apps::SettingSetTime}
+  }};
+
+  return std::make_unique<Screens::List>(1, 3, app, settingsController, applications);
+}
+
+std::unique_ptr<Screen> Settings::CreateScreen3() {
+
+  std::array<Screens::List::Applications, 4> applications {{
     {Symbols::check, "Firmware", Apps::FirmwareValidation},
     {Symbols::list, "About", Apps::SysInfo},
+    {Symbols::none, "None", Apps::None},
+    {Symbols::none, "None", Apps::None}
   }};
 
   return std::make_unique<Screens::List>(1, 2, app, settingsController, applications);
diff --git a/src/drivers/Cst816s.cpp b/src/drivers/Cst816s.cpp
index 1ff163b0..49d6ed0e 100644
--- a/src/drivers/Cst816s.cpp
+++ b/src/drivers/Cst816s.cpp
@@ -18,7 +18,7 @@ using namespace Pinetime::Drivers;
 Cst816S::Cst816S(TwiMaster& twiMaster, uint8_t twiAddress) : twiMaster {twiMaster}, twiAddress {twiAddress} {
 }
 
-void Cst816S::Init() {
+bool Cst816S::Init() {
   nrf_gpio_cfg_output(PinMap::Cst816sReset);
   nrf_gpio_pin_set(PinMap::Cst816sReset);
   vTaskDelay(50);
@@ -51,10 +51,27 @@ void Cst816S::Init() {
   */
   static constexpr uint8_t irqCtl = 0b01110000;
   twiMaster.Write(twiAddress, 0xFA, &irqCtl, 1);
+
+  // There's mixed information about which register contains which information
+  if (twiMaster.Read(twiAddress, 0xA7, &chipId, 1) == TwiMaster::ErrorCodes::TransactionFailed) {
+    chipId = 0xFF;
+    return false;
+  }
+  if (twiMaster.Read(twiAddress, 0xA8, &vendorId, 1) == TwiMaster::ErrorCodes::TransactionFailed) {
+    vendorId = 0xFF;
+    return false;
+  }
+  if (twiMaster.Read(twiAddress, 0xA9, &fwVersion, 1) == TwiMaster::ErrorCodes::TransactionFailed) {
+    fwVersion = 0xFF;
+    return false;
+  }
+
+  return chipId == 0xb4 && vendorId == 0 && fwVersion == 1;
 }
 
 Cst816S::TouchInfos Cst816S::GetTouchInfo() {
   Cst816S::TouchInfos info;
+  uint8_t touchData[7];
 
   auto ret = twiMaster.Read(twiAddress, 0, touchData, sizeof(touchData));
   if (ret != TwiMaster::ErrorCodes::NoError) {
@@ -62,18 +79,17 @@ Cst816S::TouchInfos Cst816S::GetTouchInfo() {
     return info;
   }
 
-  auto nbTouchPoints = touchData[2] & 0x0f;
+  // This can only be 0 or 1
+  uint8_t nbTouchPoints = touchData[touchPointNumIndex] & 0x0f;
 
-  auto xHigh = touchData[touchXHighIndex] & 0x0f;
-  auto xLow = touchData[touchXLowIndex];
-  uint16_t x = (xHigh << 8) | xLow;
+  uint8_t xHigh = touchData[touchXHighIndex] & 0x0f;
+  uint8_t xLow = touchData[touchXLowIndex];
+  info.x = (xHigh << 8) | xLow;
 
-  auto yHigh = touchData[touchYHighIndex] & 0x0f;
-  auto yLow = touchData[touchYLowIndex];
-  uint16_t y = (yHigh << 8) | yLow;
+  uint8_t yHigh = touchData[touchYHighIndex] & 0x0f;
+  uint8_t yLow = touchData[touchYLowIndex];
+  info.y = (yHigh << 8) | yLow;
 
-  info.x = x;
-  info.y = y;
   info.touching = (nbTouchPoints > 0);
   info.gesture = static_cast<Gestures>(touchData[gestureIndex]);
 
diff --git a/src/drivers/Cst816s.h b/src/drivers/Cst816s.h
index 7b46c5d5..0fec8419 100644
--- a/src/drivers/Cst816s.h
+++ b/src/drivers/Cst816s.h
@@ -30,11 +30,20 @@ namespace Pinetime {
       Cst816S(Cst816S&&) = delete;
       Cst816S& operator=(Cst816S&&) = delete;
 
-      void Init();
+      bool Init();
       TouchInfos GetTouchInfo();
       void Sleep();
       void Wakeup();
 
+      uint8_t GetChipId() const {
+        return chipId;
+      }
+      uint8_t GetVendorId() const {
+        return vendorId;
+      }
+      uint8_t GetFwVersion() const {
+        return fwVersion;
+      }
     private:
       // Unused/Unavailable commented out
       static constexpr uint8_t gestureIndex = 1;
@@ -49,9 +58,12 @@ namespace Pinetime {
       //static constexpr uint8_t touchXYIndex = 7;
       //static constexpr uint8_t touchMiscIndex = 8;
 
-      uint8_t touchData[7];
       TwiMaster& twiMaster;
       uint8_t twiAddress;
+
+      uint8_t chipId;
+      uint8_t vendorId;
+      uint8_t fwVersion;
     };
 
   }
diff --git a/src/systemtask/Messages.h b/src/systemtask/Messages.h
index bd1de234..5aa218d2 100644
--- a/src/systemtask/Messages.h
+++ b/src/systemtask/Messages.h
@@ -24,7 +24,7 @@ namespace Pinetime {
         SetOffAlarm,
         StopRinging,
         MeasureBatteryTimerExpired,
-        BatteryMeasurementDone,
+        BatteryPercentageUpdated,
       };
     }
 }
diff --git a/src/systemtask/SystemTask.cpp b/src/systemtask/SystemTask.cpp
index 5441c162..f1c5165a 100644
--- a/src/systemtask/SystemTask.cpp
+++ b/src/systemtask/SystemTask.cpp
@@ -23,6 +23,7 @@
 #include "drivers/Hrs3300.h"
 #include "drivers/PinMap.h"
 #include "main.h"
+#include "BootErrors.h"
 
 
 #include <memory>
@@ -116,6 +117,8 @@ void SystemTask::Process(void* instance) {
 }
 
 void SystemTask::Work() {
+  BootErrors bootError = BootErrors::None;
+
   watchdog.Setup(7);
   watchdog.Start();
   NRF_LOG_INFO("Last reset reason : %s", Pinetime::Drivers::Watchdog::ResetReasonToString(watchdog.ResetReason()));
@@ -133,10 +136,11 @@ void SystemTask::Work() {
   lcd.Init();
 
   twiMaster.Init();
-  touchPanel.Init();
+  if (!touchPanel.Init()) {
+    bootError = BootErrors::TouchController;
+  }
   dateTimeController.Register(this);
   batteryController.Register(this);
-  batteryController.Update();
   motorController.Init();
   motionSensor.SoftReset();
   timerController.Register(this);
@@ -152,25 +156,27 @@ void SystemTask::Work() {
   settingsController.Init();
 
   displayApp.Register(this);
-  displayApp.Start();
+  displayApp.Start(bootError);
 
   heartRateSensor.Init();
   heartRateSensor.Disable();
   heartRateApp.Start();
 
-  nrf_gpio_cfg_sense_input(PinMap::Button, (nrf_gpio_pin_pull_t) GPIO_PIN_CNF_PULL_Pulldown, (nrf_gpio_pin_sense_t) GPIO_PIN_CNF_SENSE_High);
+  // Button
   nrf_gpio_cfg_output(15);
   nrf_gpio_pin_set(15);
 
   nrfx_gpiote_in_config_t pinConfig;
-  pinConfig.skip_gpio_setup = true;
+  pinConfig.skip_gpio_setup = false;
   pinConfig.hi_accuracy = false;
   pinConfig.is_watcher = false;
-  pinConfig.sense = (nrf_gpiote_polarity_t) NRF_GPIOTE_POLARITY_HITOLO;
+  pinConfig.sense = (nrf_gpiote_polarity_t) NRF_GPIOTE_POLARITY_TOGGLE;
   pinConfig.pull = (nrf_gpio_pin_pull_t) GPIO_PIN_CNF_PULL_Pulldown;
 
   nrfx_gpiote_in_init(PinMap::Button, &pinConfig, nrfx_gpiote_evt_handler);
+  nrfx_gpiote_in_event_enable(PinMap::Button, true);
 
+  // Touchscreen
   nrf_gpio_cfg_sense_input(PinMap::Cst816sIrq, (nrf_gpio_pin_pull_t) GPIO_PIN_CNF_PULL_Pullup, (nrf_gpio_pin_sense_t) GPIO_PIN_CNF_SENSE_Low);
 
   pinConfig.skip_gpio_setup = true;
@@ -181,18 +187,16 @@ void SystemTask::Work() {
 
   nrfx_gpiote_in_init(PinMap::Cst816sIrq, &pinConfig, nrfx_gpiote_evt_handler);
 
+  // Power present
   pinConfig.sense = NRF_GPIOTE_POLARITY_TOGGLE;
   pinConfig.pull = NRF_GPIO_PIN_NOPULL;
   pinConfig.is_watcher = false;
   pinConfig.hi_accuracy = false;
-  pinConfig.skip_gpio_setup = true;
+  pinConfig.skip_gpio_setup = false;
   nrfx_gpiote_in_init(PinMap::PowerPresent, &pinConfig, nrfx_gpiote_evt_handler);
+  nrfx_gpiote_in_event_enable(PinMap::PowerPresent, true);
 
-  if (nrf_gpio_pin_read(PinMap::PowerPresent)) {
-    nrf_gpio_cfg_sense_input(PinMap::PowerPresent, NRF_GPIO_PIN_NOPULL, NRF_GPIO_PIN_SENSE_LOW);
-  } else {
-    nrf_gpio_cfg_sense_input(PinMap::PowerPresent, NRF_GPIO_PIN_NOPULL, NRF_GPIO_PIN_SENSE_HIGH);
-  }
+  batteryController.MeasureVoltage();
 
   idleTimer = xTimerCreate("idleTimer", pdMS_TO_TICKS(2000), pdFALSE, this, IdleTimerCallback);
   dimTimer = xTimerCreate("dimTimer", pdMS_TO_TICKS(settingsController.GetScreenTimeOut() - 2000), pdFALSE, this, DimTimerCallback);
@@ -246,12 +250,13 @@ void SystemTask::Work() {
           isDimmed = false;
           break;
         case Messages::TouchWakeUp: {
-          if(touchHandler.GetNewTouchInfo()) {
+          if (touchHandler.GetNewTouchInfo()) {
             auto gesture = touchHandler.GestureGet();
-            if (gesture != Pinetime::Drivers::Cst816S::Gestures::None and ((gesture == Pinetime::Drivers::Cst816S::Gestures::DoubleTap and
-                                settingsController.isWakeUpModeOn(Pinetime::Controllers::Settings::WakeUpMode::DoubleTap)) or
-                                (gesture == Pinetime::Drivers::Cst816S::Gestures::SingleTap and
-                                settingsController.isWakeUpModeOn(Pinetime::Controllers::Settings::WakeUpMode::SingleTap)))) {
+            if (gesture != Pinetime::Drivers::Cst816S::Gestures::None and
+                ((gesture == Pinetime::Drivers::Cst816S::Gestures::DoubleTap and
+                  settingsController.isWakeUpModeOn(Pinetime::Controllers::Settings::WakeUpMode::DoubleTap)) or
+                 (gesture == Pinetime::Drivers::Cst816S::Gestures::SingleTap and
+                  settingsController.isWakeUpModeOn(Pinetime::Controllers::Settings::WakeUpMode::SingleTap)))) {
               GoToRunning();
             }
           }
@@ -272,6 +277,8 @@ void SystemTask::Work() {
           if (settingsController.GetNotificationStatus() == Pinetime::Controllers::Settings::Notification::ON) {
             if (isSleeping && !isWakingUp) {
               GoToRunning();
+            } else {
+              ReloadIdleTimer();
             }
             displayApp.PushMessage(Pinetime::Applications::Display::Messages::NewNotification);
           }
@@ -345,18 +352,18 @@ void SystemTask::Work() {
           stepCounterMustBeReset = true;
           break;
         case Messages::OnChargingEvent:
-          batteryController.Update();
+          batteryController.ReadPowerState();
           motorController.RunForDuration(15);
+          ReloadIdleTimer();
+          if (isSleeping && !isWakingUp) {
+            GoToRunning();
+          }
           break;
         case Messages::MeasureBatteryTimerExpired:
-          sendBatteryNotification = true;
-          batteryController.Update();
+          batteryController.MeasureVoltage();
           break;
-        case Messages::BatteryMeasurementDone:
-          if (sendBatteryNotification) {
-            sendBatteryNotification = false;
-            nimbleController.NotifyBatteryLevel(batteryController.PercentRemaining());
-          }
+        case Messages::BatteryPercentageUpdated:
+          nimbleController.NotifyBatteryLevel(batteryController.PercentRemaining());
           break;
 
         default:
diff --git a/src/systemtask/SystemTask.h b/src/systemtask/SystemTask.h
index 1fcfeb8a..879c1be8 100644
--- a/src/systemtask/SystemTask.h
+++ b/src/systemtask/SystemTask.h
@@ -133,14 +133,12 @@ namespace Pinetime {
       TimerHandle_t dimTimer;
       TimerHandle_t idleTimer;
       TimerHandle_t measureBatteryTimer;
-      bool sendBatteryNotification = false;
       bool doNotGoToSleep = false;
 
       void GoToRunning();
       void UpdateMotion();
       bool stepCounterMustBeReset = false;
       static constexpr TickType_t batteryMeasurementPeriod = pdMS_TO_TICKS(10 * 60 * 1000);
-      TickType_t lastBatteryNotificationTime = 0;
 
 #if configUSE_TRACE_FACILITY == 1
       SystemMonitor<FreeRtosMonitor> monitor;