Freeform Esp32 Ios Notification Display

Made by phuzybuny / Displays / Notifications

About the project

A freeform desktop display for incoming iOS notifications. Utilizes female headers so that components can be reused and ESP-IDF FreeRTOS with Arduino to manage incoming BLE Notifications, display text, and backlight with timeout.

Project info

Difficulty: Moderate

Platforms: Arduino, Espressif

Estimated time: 3 hours

License: GNU General Public License, version 3 or later (GPL3+)

Items used in this project

Hardware components

	NodeMCU-32S Alternatively, any other equivalent ESP32 development board.	x 1
	I2C 1602 Arduino LCD Screen Optional: I2C module to reduce the number of pins but may compromise the rigidity of the freeform	x 1
	Breadboard Trim Potentiometer Used to adjust the contrast of the 1602 LCD display; 20k Ohm was used.	x 1
	Header Kit for Feather - 12-pin and 16-pin Female Header Set	x 1
	A2SHB N-Channel MOSFET Used to switch the display backlight.	x 1
	18AWG Tinned Copper Wire Used to make connections.	x 1
	M2 Screws	x 1
	Brass M2 Inserts	x 1

View all

Software apps and online services

ESP-IDP FreeRTOS

Hand tools and fabrication machines

	Needle nose Plier	x 1
	Flush cutter	x 1
	Soldering Iron	x 1
	Solder	x 1

Story

Problem

Having to retrieve my phone to review incoming notifications.

Solution

A desktop display connected wirelessly would allow for me to review notifications without the need to retrieve my phone.

Objectives

Connect to iPhone wirelessly: The ESP32 with its BLE capabilities was a good fit for this requirement. However, I was not experienced in BLE so a library would be needed to facilitate this requirement.

Display Text: I had a spare 1602 display available and its relatively large display (compared to SSD1306 OLEDs) was ideal for this application.

Backlight with Timeout: To make changes - wireless connectivity activity or incoming notifications - more noticeable, I wanted the backlight to turn on whenever a change occurred and then off after some time.

Angled Display: I wanted the display to reside on my desk at a convenient angle for viewing.

Achievements

Having recently reviewed Digi-Key's FreeRTOS series on YouTube, this was an ideal first project to try out a RTOS.

Connect to iPhone wirelessly : Thanks to the ESP32 ANCS Notifications library, it was relatively straightforward to connect to an iPhone for wireless BLE notifications.

Display Text: The Arduino Liquid Crystal library was used to display the notification text to the 1602 display.

Backlight with Timeout: Using a N-Channel MOSFET, the 1602 display backlight could be turned on then off after sometime with a single digital pin.

Angled Display: The freeform wiring allowed for the display to be angled as desired and would hold the ESP32 development board in proximity as a single package.

Photos

Above: 1602 display and tinned copper wire. M2 screws and brass inserts were screwed onto the display to make the frame more rigid.

Above: Female headers used to facilitate removal of components if needed.

Above: Potentiometer added for display contrast adjustment. ESP32 base also taking shape.

Above: The 'marriage' of the two freeform frames into a single piece. Still need to complete the remaining connections.

Above: Connections completed.

Above: Components needed.

Above: BLE Connected

Code

Notification LCD

#include "esp32notifications.h"
#include <LiquidCrystal.h>

// Only use 1 core
#if CONFIG_FREERTOS_UNICORE
  static const BaseType_t app_cpu = 0;
#else
  static const BaseType_t pro_cpu = 0;
  static const BaseType_t app_cpu = 1;
#endif


// Settings
static const uint8_t LCD_RS = 32;
static const uint8_t LCD_ENABLE = 33;
static const uint8_t LCD_D4 = 25;
static const uint8_t LCD_D5 = 26;
static const uint8_t LCD_D6 = 27;
static const uint8_t LCD_D7 = 14;
static const uint8_t BACKLIGHT = 13;
static const uint16_t BACKLIGHT_TIMEOUT_MS = 7000;  // milliseconds
static const char* BLE_NAME = "Notification Display";
static const uint8_t msg_queue_len = 5;


// Globals
static TaskHandle_t toggle_backlight_task = NULL;
static SemaphoreHandle_t sem_backlight;
BLENotifications notifications;
static QueueHandle_t msg_queue;


void toggleBacklight(void *parameters) {
  pinMode(BACKLIGHT, OUTPUT);
  
  while (1) {
    // Wait for notification
    xSemaphoreTake(sem_backlight, portMAX_DELAY);

    // Toggle LED Backlight
    digitalWrite(BACKLIGHT, HIGH);  // turn backlight ON
    vTaskDelay(BACKLIGHT_TIMEOUT_MS / portTICK_PERIOD_MS);
    digitalWrite(BACKLIGHT, LOW);  // turn backlight OFF
  }
}


void printLCD(void *parameters) {
  char lines[2][17];

  LiquidCrystal lcd(LCD_RS, LCD_ENABLE, LCD_D4, LCD_D5, LCD_D6, LCD_D7);  // rs, enable, d4, d5, d6, d7
  lcd.begin(16, 2);  // begin(columns, rows)

  while (1) {
    if (xQueueReceive(msg_queue, (void *)&lines, 0) == pdTRUE) {
      xSemaphoreGive(sem_backlight);

      lcd.clear();
      lcd.write(lines[0]);
      lcd.setCursor(0, 1);  // setCursor(column, row)
      lcd.write(lines[1]);
    }
  }
}


void onNotificationArrived(const ArduinoNotification * notification, const Notification * rawNotificationData) {
  char lines[2][17];
  notification->message.toCharArray(lines[0], 17);
  lines[0][16] = '\0';
  notification->message.substring(16).toCharArray(lines[1], 17);
  lines[1][16] = '\0';
  
  if (xQueueSend(msg_queue, (void *)&lines, 10) != pdTRUE) {
    Serial.println("ERROR: Could not put item in message queue.");
  }
}


void onBLEStateChange(BLENotifications::State state) {
  char lines[2][17];

  switch(state) {
    case BLENotifications::StateConnected:
      strncpy(lines[0], "BLE Connected", sizeof(char[17]));
      break;
    case BLENotifications::StateDisconnected:
      strncpy(lines[0], "BLE Disconnected", sizeof(char[17]));
      notifications.startAdvertising();
      break;
  }

  lines[1][0] = '\0';  // clear the second line

  if (xQueueSend(msg_queue, (void *)&lines, 10) != pdTRUE) {
    Serial.println("ERROR: Could not put item in message queue.");
  }
}


void setup(){

  // Create semaphores
  sem_backlight = xSemaphoreCreateBinary();  // Will be initialized to 0 by default

  // Create queues
  msg_queue = xQueueCreate(msg_queue_len, sizeof(char[2][17]));
  
  xTaskCreatePinnedToCore(
    toggleBacklight,        // Function to be called
    "Toggle backlight",     // Name of task
    1024,                   // Stack size (bytes in ESP32, words in FreeRTOS)
    NULL,                   // Parameter to pass to function
    1,                      // Task priority (0 to configMAX_PRIORITIES - 1)
    &toggle_backlight_task, // Task handle
    app_cpu                 // Run on one core for demo purposes (ESP32 only)
  );
  
  xTaskCreatePinnedToCore(
    printLCD,               // Function to be called
    "Print LCD",            // Name of task
    1024,                   // Stack size (bytes in ESP32, words in FreeRTOS)
    NULL,                   // Parameter to pass to function
    1,                      // Task priority (0 to configMAX_PRIORITIES - 1)
    NULL,                   // Task handle
    app_cpu                 // Run on one core for demo purposes (ESP32 only)
  );

  notifications.begin(BLE_NAME);
  notifications.setNotificationCallback(onNotificationArrived);
  notifications.setConnectionStateChangedCallback(onBLEStateChange);

  // Delete "setup" and "loop" tasks
  vTaskDelete(NULL);
}

void loop(){
}

Shop

Project Hub

Video

Blog

Shop home

3D printing

Single Board Computers

Development kits

Sensors

Internet of things

Robotics

Accessories

Product of the Week

Electromaker Educator

The Electromaker Show

The Electromaker Podcast

Freeform Esp32 Ios Notification Display

About the project

Project info