implemented continuous vibration pattern for incoming calls

src/components/motor/MotorController.cpp

@@ -3,7 +3,8 @@
 #include "systemtask/SystemTask.h"
 #include "app_timer.h"
 
-APP_TIMER_DEF(vibTimer);
+APP_TIMER_DEF(shortVibTimer);
+APP_TIMER_DEF(longVibTimer);
 
 using namespace Pinetime::Controllers;
 
@@ -14,19 +15,42 @@ void MotorController::Init() {
   nrf_gpio_cfg_output(pinMotor);
   nrf_gpio_pin_set(pinMotor);
   app_timer_init();
-  app_timer_create(&vibTimer, APP_TIMER_MODE_SINGLE_SHOT, vibrate);
+  
+  app_timer_create(&shortVibTimer, APP_TIMER_MODE_SINGLE_SHOT, vibrate);
+  app_timer_create(&longVibTimer, APP_TIMER_MODE_REPEATED, vibrate);
+  isBusy = false;
 }
 
-void MotorController::SetDuration(uint8_t motorDuration) {
+void MotorController::RunForDuration(uint8_t motorDuration) {
 
-  if (settingsController.GetVibrationStatus() == Controllers::Settings::Vibration::OFF)
+  if (settingsController.GetVibrationStatus() == Controllers::Settings::Vibration::OFF || isBusy)
     return;
 
   nrf_gpio_pin_clear(pinMotor);
   /* Start timer for motorDuration miliseconds and timer triggers vibrate() when it finishes*/
-  app_timer_start(vibTimer, APP_TIMER_TICKS(motorDuration), NULL);
+  app_timer_start(shortVibTimer, APP_TIMER_TICKS(motorDuration), NULL);
+}
+
+void MotorController::startRunning(uint8_t motorDuration) {
+  if (settingsController.GetVibrationStatus() == Controllers::Settings::Vibration::OFF || isBusy )
+    return;
+  //prevent other vibrations while running
+  isBusy = true;
+  nrf_gpio_pin_clear(pinMotor);
+  app_timer_start(longVibTimer, APP_TIMER_TICKS(motorDuration), NULL);
+}
+
+void MotorController::stopRunning() {
+  
+  app_timer_stop(longVibTimer);
+  nrf_gpio_pin_set(pinMotor);
+  isBusy = false;
 }
 
 void MotorController::vibrate(void* p_context) {
-  nrf_gpio_pin_set(pinMotor);
+  if (nrf_gpio_pin_out_read(pinMotor) == 0) {
+    nrf_gpio_pin_set(pinMotor);
+  } else {
+    nrf_gpio_pin_clear(pinMotor);
+  }
 }

src/components/motor/MotorController.h

@@ -12,11 +12,14 @@ namespace Pinetime {
     public:
       MotorController(Controllers::Settings& settingsController);
       void Init();
-      void SetDuration(uint8_t motorDuration);
+      void RunForDuration(uint8_t motorDuration);
+      void startRunning(uint8_t motorDuration);
+      void stopRunning();
 
     private:
       Controllers::Settings& settingsController;
       static void vibrate(void* p_context);
-    };
+      bool isBusy;
+      };
   }
 }

src/displayapp/DisplayApp.cpp

@@ -256,12 +256,12 @@ void DisplayApp::LoadApp(Apps app, DisplayApp::FullRefreshDirections direction)
 
     case Apps::Notifications:
       currentScreen = std::make_unique<Screens::Notifications>(
-        this, notificationManager, systemTask.nimble().alertService(), Screens::Notifications::Modes::Normal);
+        this, notificationManager, systemTask.nimble().alertService(), motorController, Screens::Notifications::Modes::Normal);
       ReturnApp(Apps::Clock, FullRefreshDirections::Up, TouchEvents::SwipeUp);
       break;
     case Apps::NotificationsPreview:
       currentScreen = std::make_unique<Screens::Notifications>(
-        this, notificationManager, systemTask.nimble().alertService(), Screens::Notifications::Modes::Preview);
+        this, notificationManager, systemTask.nimble().alertService(), motorController, Screens::Notifications::Modes::Preview);
       ReturnApp(Apps::Clock, FullRefreshDirections::Up, TouchEvents::SwipeUp);
       break;
 

src/displayapp/screens/Notifications.cpp

@@ -11,8 +11,13 @@ extern lv_font_t jetbrains_mono_bold_20;
 Notifications::Notifications(DisplayApp* app,
                              Pinetime::Controllers::NotificationManager& notificationManager,
                              Pinetime::Controllers::AlertNotificationService& alertNotificationService,
+                             Controllers::MotorController& motorController,
                              Modes mode)
-  : Screen(app), notificationManager {notificationManager}, alertNotificationService {alertNotificationService}, mode {mode} {
+  : Screen(app),
+  notificationManager {notificationManager},
+  alertNotificationService {alertNotificationService},
+  motorController{motorController},
+  mode {mode} {
   notificationManager.ClearNewNotificationFlag();
   auto notification = notificationManager.GetLastNotification();
   if (notification.valid) {
@@ -23,7 +28,8 @@ Notifications::Notifications(DisplayApp* app,
                                                      notification.category,
                                                      notificationManager.NbNotifications(),
                                                      mode,
-                                                     alertNotificationService);
+                                                     alertNotificationService,
+                                                     motorController);
     validDisplay = true;
   } else {
     currentItem = std::make_unique<NotificationItem>("Notification",
@@ -32,10 +38,13 @@ Notifications::Notifications(DisplayApp* app,
                                                      notification.category,
                                                      notificationManager.NbNotifications(),
                                                      Modes::Preview,
-                                                     alertNotificationService);
+                                                     alertNotificationService,
+                                                     motorController);
   }
 
   if (mode == Modes::Preview) {
+    
+    
 
     timeoutLine = lv_line_create(lv_scr_act(), nullptr);
 
@@ -63,7 +72,10 @@ bool Notifications::Refresh() {
     timeoutLinePoints[1].x = pos;
     lv_line_set_points(timeoutLine, timeoutLinePoints, 2);
   }
-
+  //make sure we stop any vibrations before exiting
+  if (!running) {
+    motorController.stopRunning();
+  }
   return running;
 }
 
@@ -92,7 +104,8 @@ bool Notifications::OnTouchEvent(Pinetime::Applications::TouchEvents event) {
                                                        previousNotification.category,
                                                        notificationManager.NbNotifications(),
                                                        mode,
-                                                       alertNotificationService);
+                                                       alertNotificationService,
+                                                       motorController);
     }
       return true;
     case Pinetime::Applications::TouchEvents::SwipeUp: {
@@ -117,7 +130,8 @@ bool Notifications::OnTouchEvent(Pinetime::Applications::TouchEvents event) {
                                                        nextNotification.category,
                                                        notificationManager.NbNotifications(),
                                                        mode,
-                                                       alertNotificationService);
+                                                       alertNotificationService,
+                                                       motorController);
     }
       return true;
     case Pinetime::Applications::TouchEvents::LongTap: {
@@ -152,8 +166,9 @@ Notifications::NotificationItem::NotificationItem(const char* title,
                                                   Controllers::NotificationManager::Categories category,
                                                   uint8_t notifNb,
                                                   Modes mode,
-                                                  Pinetime::Controllers::AlertNotificationService& alertNotificationService)
+                                                  Pinetime::Controllers::AlertNotificationService& alertNotificationService,
-  : notifNr {notifNr}, notifNb {notifNb}, mode {mode}, alertNotificationService {alertNotificationService} {
+                                                  Controllers::MotorController& motorController)
+  : notifNr {notifNr}, notifNb {notifNb}, mode {mode}, alertNotificationService {alertNotificationService}, motorController{motorController} {
 
   lv_obj_t* container1 = lv_cont_create(lv_scr_act(), NULL);
 
@@ -236,8 +251,10 @@ Notifications::NotificationItem::NotificationItem(const char* title,
       label_mute = lv_label_create(bt_mute, nullptr);
       lv_label_set_text(label_mute, Symbols::volumMute);
       lv_obj_set_style_local_bg_color(bt_mute, LV_LABEL_PART_MAIN, LV_STATE_DEFAULT, LV_COLOR_GRAY);
+  
     } break;
   }
+  
 
   lv_obj_t* backgroundLabel = lv_label_create(lv_scr_act(), nullptr);
   lv_label_set_long_mode(backgroundLabel, LV_LABEL_LONG_CROP);
@@ -249,21 +266,21 @@ Notifications::NotificationItem::NotificationItem(const char* title,
 void Notifications::NotificationItem::OnAcceptIncomingCall(lv_event_t event) {
   if (event != LV_EVENT_CLICKED)
     return;
-
+  motorController.stopRunning();
   alertNotificationService.AcceptIncomingCall();
 }
 
 void Notifications::NotificationItem::OnMuteIncomingCall(lv_event_t event) {
   if (event != LV_EVENT_CLICKED)
     return;
-
+  motorController.stopRunning();
   alertNotificationService.MuteIncomingCall();
 }
 
 void Notifications::NotificationItem::OnRejectIncomingCall(lv_event_t event) {
   if (event != LV_EVENT_CLICKED)
     return;
-
+  motorController.stopRunning();
   alertNotificationService.RejectIncomingCall();
 }
 

src/displayapp/screens/Notifications.h

@@ -5,6 +5,7 @@
 #include <memory>
 #include "Screen.h"
 #include "components/ble/NotificationManager.h"
+#include "components/motor/MotorController.h"
 
 namespace Pinetime {
   namespace Controllers {
@@ -19,6 +20,7 @@ namespace Pinetime {
         explicit Notifications(DisplayApp* app,
                                Pinetime::Controllers::NotificationManager& notificationManager,
                                Pinetime::Controllers::AlertNotificationService& alertNotificationService,
+                               Controllers::MotorController& motorController,
                                Modes mode);
         ~Notifications() override;
 
@@ -33,7 +35,8 @@ namespace Pinetime {
                            Controllers::NotificationManager::Categories,
                            uint8_t notifNb,
                            Modes mode,
-                           Pinetime::Controllers::AlertNotificationService& alertNotificationService);
+                           Pinetime::Controllers::AlertNotificationService& alertNotificationService,
+                           Controllers::MotorController& motorController);
           ~NotificationItem();
           bool Refresh() {
             return false;
@@ -60,6 +63,7 @@ namespace Pinetime {
           lv_obj_t* bottomPlaceholder;
           Modes mode;
           Pinetime::Controllers::AlertNotificationService& alertNotificationService;
+          Controllers::MotorController& motorController;
         };
 
       private:
@@ -72,6 +76,8 @@ namespace Pinetime {
         Modes mode = Modes::Normal;
         std::unique_ptr<NotificationItem> currentItem;
         Controllers::NotificationManager::Notification::Id currentId;
+        Controllers::MotorController& motorController;
+        
         bool validDisplay = false;
 
         lv_point_t timeoutLinePoints[2] {{0, 1}, {239, 1}};

src/displayapp/screens/settings/QuickSettings.cpp

@@ -140,7 +140,7 @@ void QuickSettings::OnButtonEvent(lv_obj_t* object, lv_event_t event) {
 
     if (lv_obj_get_state(btn3, LV_BTN_PART_MAIN) & LV_STATE_CHECKED) {
       settingsController.SetVibrationStatus(Controllers::Settings::Vibration::ON);
-      motorController.SetDuration(35);
+      motorController.RunForDuration(35);
       lv_label_set_text_static(btn3_lvl, Symbols::notificationsOn);
     } else {
       settingsController.SetVibrationStatus(Controllers::Settings::Vibration::OFF);

src/systemtask/SystemTask.cpp

@@ -225,7 +225,11 @@ void SystemTask::Work() {
         case Messages::OnNewNotification:
           if (isSleeping && !isWakingUp)
             GoToRunning();
-          motorController.SetDuration(35);
+          if (notificationManager.GetLastNotification().category == Controllers::NotificationManager::Categories::IncomingCall) {
+            motorController.startRunning(50);
+          } else {
+            motorController.RunForDuration(35);
+          }
           displayApp->PushMessage(Pinetime::Applications::Display::Messages::NewNotification);
           break;
         case Messages::BleConnected: