diy smartwatch using 129x64 oled display problem

[nshiva7986]

/*
RetroWatch Arduino is a part of open source smart watch project.
Copyright (C) 2014 Suh Young Bae

This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program.  If not, see [http://www.gnu.org/licenses/].

/
/
Retro Watch Arduino v1.0

Get the latest version, android host app at
------> https://github.com/godstale/retrowatch
------> or http://www.hardcopyworld.com

Written by Suh Young Bae (godstale@hotmail.com)
All text above, and the first splash screen(Adafruit) must be included in any redistribution
*/

//#include <avr/pgmspace.h>
#include <Wire.h>
#include <SoftwareSerial.h>
#include <Adafruit_GFX.h>
#include <Adafruit_SSD1306.h>
#include <math.h>
#include "bitmap.h"

///////////////////////////////////////////////////////////////////
//----- OLED instance
#define OLED_RESET 9
Adafruit_SSD1306 display(OLED_RESET);

#if (SSD1306_LCDHEIGHT != 64)
#error("Height incorrect, please fix Adafruit_SSD1306.h!");
#endif
///////////////////////////////////////////////////////////////////

///////////////////////////////////////////////////////////////////
//----- BT instance
SoftwareSerial BTSerial(2, 3); //Connect HC-06, RX, TX
///////////////////////////////////////////////////////////////////

//----- Bluetooth transaction parsing
#define TR_MODE_IDLE 1
#define TR_MODE_WAIT_CMD 11
#define TR_MODE_WAIT_MESSAGE 101
#define TR_MODE_WAIT_TIME 111
#define TR_MODE_WAIT_ID 121
#define TR_MODE_WAIT_COMPLETE 201

#define TRANSACTION_START_BYTE 0xfc
#define TRANSACTION_END_BYTE 0xfd

#define CMD_TYPE_NONE 0x00
#define CMD_TYPE_RESET_EMERGENCY_OBJ 0x05
#define CMD_TYPE_RESET_NORMAL_OBJ 0x02
#define CMD_TYPE_RESET_USER_MESSAGE 0x03

#define CMD_TYPE_ADD_EMERGENCY_OBJ 0x11
#define CMD_TYPE_ADD_NORMAL_OBJ 0x12
#define CMD_TYPE_ADD_USER_MESSAGE 0x13

#define CMD_TYPE_DELETE_EMERGENCY_OBJ 0x21
#define CMD_TYPE_DELETE_NORMAL_OBJ 0x22
#define CMD_TYPE_DELETE_USER_MESSAGE 0x23

#define CMD_TYPE_SET_TIME 0x31
#define CMD_TYPE_REQUEST_MOVEMENT_HISTORY 0x32
#define CMD_TYPE_SET_CLOCK_STYLE 0x33
#define CMD_TYPE_SET_INDICATOR 0x34

#define CMD_TYPE_PING 0x51
#define CMD_TYPE_AWAKE 0x52
#define CMD_TYPE_SLEEP 0x53
#define CMD_TYPE_REBOOT 0x54

byte TRANSACTION_POINTER = TR_MODE_IDLE;
byte TR_COMMAND = CMD_TYPE_NONE;

//----- Message item buffer
#define MSG_COUNT_MAX 7
#define MSG_BUFFER_MAX 19
unsigned char msgBuffer[MSG_COUNT_MAX][MSG_BUFFER_MAX];
char msgParsingLine = 0;
char msgParsingChar = 0;
char msgCurDisp = 0;

//----- Emergency item buffer
#define EMG_COUNT_MAX 3
#define EMG_BUFFER_MAX 19
char emgBuffer[EMG_COUNT_MAX][EMG_BUFFER_MAX];
char emgParsingLine = 0;
char emgParsingChar = 0;
char emgCurDisp = 0;

//----- Time
#define UPDATE_TIME_INTERVAL 60000
byte iMonth = 1;
byte iDay = 1;
byte iWeek = 1; // 1: SUN, MON, TUE, WED, THU, FRI,SAT
byte iAmPm = 0; // 0:AM, 1:PM
byte iHour = 0;
byte iMinutes = 0;
byte iSecond = 0;

#define TIME_BUFFER_MAX 6
char timeParsingIndex = 0;
char timeBuffer[6] = {-1, -1, -1, -1, -1, -1};
PROGMEM const char* weekString[] = {"", "Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"};
PROGMEM const char* ampmString[] = {"AM", "PM"};

//----- Display features
#define DISPLAY_MODE_START_UP 0
#define DISPLAY_MODE_CLOCK 1
#define DISPLAY_MODE_EMERGENCY_MSG 2
#define DISPLAY_MODE_NORMAL_MSG 3
#define DISPLAY_MODE_IDLE 11
byte displayMode = DISPLAY_MODE_START_UP;

#define CLOCK_STYLE_SIMPLE_ANALOG 0x01
#define CLOCK_STYLE_SIMPLE_DIGIT 0x02
#define CLOCK_STYLE_SIMPLE_MIX 0x03
byte clockStyle = CLOCK_STYLE_SIMPLE_MIX;

#define INDICATOR_ENABLE 0x01
boolean updateIndicator = true;

byte centerX = 64;
byte centerY = 32;
byte iRadius = 28;

#define IDLE_DISP_INTERVAL 60000
#define CLOCK_DISP_INTERVAL 60000
#define EMERGENCY_DISP_INTERVAL 5000
#define MESSAGE_DISP_INTERVAL 3000
unsigned long prevClockTime = 0;
unsigned long prevDisplayTime = 0;

unsigned long next_display_interval = 0;
unsigned long mode_change_timer = 0;
#define CLOCK_DISPLAY_TIME 300000
#define EMER_DISPLAY_TIME 10000
#define MSG_DISPLAY_TIME 5000

//----- Button control
//int buttonPin = 5;
boolean isClicked = HIGH;

void setup() {
//Serial.begin(9600); // Do not enable serial. This makes serious problem because of shortage of RAM.
//pinMode(buttonPin, INPUT); // Defines button pin

init_emg_array();
init_msg_array();

//----- by default, we'll generate the high voltage from the 3.3v line internally! (neat!)
display.begin(SSD1306_SWITCHCAPVCC, 0x3c); // initialize with the I2C addr 0x3D (for the 128x64)
display.display(); // show splashscreen
delay(1000);
drawStartUp(); // Show RetroWatch Logo
centerX = display.width() / 2;
centerY = display.height() / 2;
iRadius = centerY - 2;

BTSerial.begin(9600); // set the data rate for the BT port
}

void loop() {
boolean isReceived = false;
unsigned long current_time = 0;

// Get button input
//if(digitalRead(buttonPin) == LOW) isClicked = LOW;

// Receive data from remote and parse
isReceived = receiveBluetoothData();

// Update clock time
current_time = millis();
updateTime(current_time);

// Display routine
onDraw(current_time);

// If data doesn't arrive, wait for a while to save battery
if(!isReceived)
delay(300);
}

///////////////////////////////////
//----- Utils
///////////////////////////////////
void init_msg_array() {
for(int i=0; i<MSG_COUNT_MAX; i++) {
for(int j=0; j<MSG_BUFFER_MAX; j++) {
msgBuffer[i][j] = 0x00;
}
}
msgParsingLine = 0;
msgParsingChar = 0; // First 2 byte is management byte
msgCurDisp = 0;
}

void init_emg_array() {
for(int i=0; i<EMG_COUNT_MAX; i++) {
for(int j=0; j<EMG_BUFFER_MAX; j++) {
emgBuffer[i][j] = 0x00;
}
}
emgParsingLine = 0;
emgParsingChar = 0; // First 2 byte is management byte
emgCurDisp = 0;
}

///////////////////////////////////
//----- Time functions
///////////////////////////////////
void setTimeValue() {
iMonth = timeBuffer[0];
iDay = timeBuffer[1];
iWeek = timeBuffer[2]; // 1: SUN, MON, TUE, WED, THU, FRI,SAT
iAmPm = timeBuffer[3]; // 0:AM, 1:PM
iHour = timeBuffer[4];
iMinutes = timeBuffer[5];
}

void updateTime(unsigned long current_time) {
if(iMinutes >= 0) {
if(current_time - prevClockTime > UPDATE_TIME_INTERVAL) {
// Increase time
iMinutes++;
if(iMinutes >= 60) {
iMinutes = 0;
iHour++;
if(iHour > 12) {
iHour = 1;
(iAmPm == 0) ? iAmPm=1 : iAmPm=0;
if(iAmPm == 0) {
iWeek++;
if(iWeek > 7)
iWeek = 1;
iDay++;
if(iDay > 30) // Yes. day is not exact.
iDay = 1;
}
}
}
prevClockTime = current_time;
}
}
else {
displayMode = DISPLAY_MODE_START_UP;
}
}

///////////////////////////////////
//----- BT, Data parsing functions
///////////////////////////////////

// Parsing packet according to current mode
boolean receiveBluetoothData() {
int isTransactionEnded = false;
while(!isTransactionEnded) {
if(BTSerial.available()) {
byte c = BTSerial.read();

  if(c == 0xFF && TRANSACTION_POINTER != TR_MODE_WAIT_MESSAGE) return false;
  
  if(TRANSACTION_POINTER == TR_MODE_IDLE) {
    parseStartSignal(c);
  }
  else if(TRANSACTION_POINTER == TR_MODE_WAIT_CMD) {
    parseCommand(c);
  }
  else if(TRANSACTION_POINTER == TR_MODE_WAIT_MESSAGE) {
    parseMessage(c);
  }
  else if(TRANSACTION_POINTER == TR_MODE_WAIT_TIME) {
    parseTime(c);
  }
  else if(TRANSACTION_POINTER == TR_MODE_WAIT_ID) {
    parseId(c);
  }
  else if(TRANSACTION_POINTER == TR_MODE_WAIT_COMPLETE) {
    isTransactionEnded = parseEndSignal(c);
  }
  
}  // End of if(BTSerial.available())
else {
  isTransactionEnded = true;
}

} // End of while()
return true;
} // End of receiveBluetoothData()

void parseStartSignal(byte c) {
//drawLogChar(c);
if(c == TRANSACTION_START_BYTE) {
TRANSACTION_POINTER = TR_MODE_WAIT_CMD;
TR_COMMAND = CMD_TYPE_NONE;
}
}

void parseCommand(byte c) {
if(c == CMD_TYPE_RESET_EMERGENCY_OBJ || c == CMD_TYPE_RESET_NORMAL_OBJ || c == CMD_TYPE_RESET_USER_MESSAGE) {
TRANSACTION_POINTER = TR_MODE_WAIT_COMPLETE;
TR_COMMAND = c;
processTransaction();
}
else if(c == CMD_TYPE_ADD_EMERGENCY_OBJ || c == CMD_TYPE_ADD_NORMAL_OBJ || c == CMD_TYPE_ADD_USER_MESSAGE) {
TRANSACTION_POINTER = TR_MODE_WAIT_MESSAGE;
TR_COMMAND = c;
if(c == CMD_TYPE_ADD_EMERGENCY_OBJ) {
emgParsingChar = 0;
if(emgParsingLine >= MSG_COUNT_MAX || emgParsingLine < 0)
emgParsingLine = 0;
}
else if(c == CMD_TYPE_ADD_NORMAL_OBJ) {
msgParsingChar = 0;
if(msgParsingLine >= MSG_COUNT_MAX || msgParsingLine < 0)
msgParsingLine = 0;
}
}
else if(c == CMD_TYPE_DELETE_EMERGENCY_OBJ || c == CMD_TYPE_DELETE_NORMAL_OBJ || c == CMD_TYPE_DELETE_USER_MESSAGE) {
TRANSACTION_POINTER = TR_MODE_WAIT_COMPLETE;
TR_COMMAND = c;
}
else if(c == CMD_TYPE_SET_TIME) {
TRANSACTION_POINTER = TR_MODE_WAIT_TIME;
TR_COMMAND = c;
}
else if(c == CMD_TYPE_SET_CLOCK_STYLE || c == CMD_TYPE_SET_INDICATOR) {
TRANSACTION_POINTER = TR_MODE_WAIT_ID;
TR_COMMAND = c;
}
else {
TRANSACTION_POINTER = TR_MODE_IDLE;
TR_COMMAND = CMD_TYPE_NONE;
}
}

void parseMessage(byte c) {
if(c == TRANSACTION_END_BYTE) {
processTransaction();
TRANSACTION_POINTER = TR_MODE_IDLE;
}

if(TR_COMMAND == CMD_TYPE_ADD_EMERGENCY_OBJ) {
if(emgParsingChar < EMG_BUFFER_MAX - 1) {
if(emgParsingChar > 1) {
emgBuffer[emgParsingLine][emgParsingChar] = c;
}
emgParsingChar++;
}
else {
TRANSACTION_POINTER = TR_MODE_IDLE;
processTransaction();
}
}
else if(TR_COMMAND == CMD_TYPE_ADD_NORMAL_OBJ) {
if(msgParsingChar < MSG_BUFFER_MAX - 1) {
if(msgParsingChar > 1) {
msgBuffer[msgParsingLine][msgParsingChar] = c;
}
msgParsingChar++;
}
else {
TRANSACTION_POINTER = TR_MODE_IDLE;
processTransaction();
}
}
else if(TR_COMMAND == CMD_TYPE_ADD_USER_MESSAGE) {
// Not available yet.
TRANSACTION_POINTER = TR_MODE_WAIT_COMPLETE;
}
}

void parseTime(byte c) {
if(TR_COMMAND == CMD_TYPE_SET_TIME) {
if(timeParsingIndex >= 0 && timeParsingIndex < TIME_BUFFER_MAX) {
timeBuffer[timeParsingIndex] = (int)c;
timeParsingIndex++;
}
else {
processTransaction();
TRANSACTION_POINTER = TR_MODE_WAIT_COMPLETE;
}
}
}

void parseId(byte c) {
if(TR_COMMAND == CMD_TYPE_SET_CLOCK_STYLE) {
clockStyle = c;
processTransaction();
}
else if(TR_COMMAND == CMD_TYPE_SET_INDICATOR) {
if(c == INDICATOR_ENABLE)
updateIndicator = true;
else
updateIndicator = false;
processTransaction();
}
TRANSACTION_POINTER = TR_MODE_WAIT_COMPLETE;
}

boolean parseEndSignal(byte c) {
if(c == TRANSACTION_END_BYTE) {
TRANSACTION_POINTER = TR_MODE_IDLE;
return true;
}
return false;
}

void processTransaction() {
if(TR_COMMAND == CMD_TYPE_RESET_EMERGENCY_OBJ) {
init_emg_array();//init_msg_array();
}
else if(TR_COMMAND == CMD_TYPE_RESET_NORMAL_OBJ) {
init_msg_array();//init_emg_array();
}
else if(TR_COMMAND == CMD_TYPE_RESET_USER_MESSAGE) {
// Not available yet.
}
else if(TR_COMMAND == CMD_TYPE_ADD_NORMAL_OBJ) {
msgBuffer[msgParsingLine][0] = 0x01;
msgBuffer[msgParsingLine][MSG_BUFFER_MAX - 1] = 0x00;
msgParsingChar = 0;
msgParsingLine++;
if(msgParsingLine >= MSG_COUNT_MAX)
msgParsingLine = 0;
setNextDisplayTime(millis(), 0); // update screen immediately
}
else if(TR_COMMAND == CMD_TYPE_ADD_EMERGENCY_OBJ) {
emgBuffer[emgParsingLine][0] = 0x01;
emgBuffer[emgParsingLine][EMG_BUFFER_MAX - 1] = 0x00;
emgParsingChar = 0;
emgParsingLine++;
if(emgParsingLine >= EMG_COUNT_MAX)
emgParsingLine = 0;
startEmergencyMode();
setNextDisplayTime(millis(), 2000);
}
else if(TR_COMMAND == CMD_TYPE_ADD_USER_MESSAGE) {
}
else if(TR_COMMAND == CMD_TYPE_DELETE_EMERGENCY_OBJ || TR_COMMAND == CMD_TYPE_DELETE_NORMAL_OBJ || TR_COMMAND == CMD_TYPE_DELETE_USER_MESSAGE) {
// Not available yet.
}
else if(TR_COMMAND == CMD_TYPE_SET_TIME) {
setTimeValue();
timeParsingIndex = 0;
setNextDisplayTime(millis(), 0); // update screen immediately
}
if(TR_COMMAND == CMD_TYPE_SET_CLOCK_STYLE || CMD_TYPE_SET_INDICATOR) {
setNextDisplayTime(millis(), 0); // update screen immediately
}
}

///////////////////////////////////
//----- Drawing methods
///////////////////////////////////

// Main drawing routine.
// Every drawing starts here.
void onDraw(unsigned long currentTime) {
if(!isDisplayTime(currentTime)) // Do not re-draw at every tick
return;

if(displayMode == DISPLAY_MODE_START_UP) {
drawStartUp();
}
else if(displayMode == DISPLAY_MODE_CLOCK) {
if(isClicked == LOW) { // User input received
startEmergencyMode();
setPageChangeTime(0); // Change mode with no page-delay
setNextDisplayTime(currentTime, 0); // Do not wait next re-draw time
}
else {
drawClock();

  if(isPageChangeTime(currentTime)) {  // It's time to go into idle mode
    startIdleMode();
    setPageChangeTime(currentTime);  // Set a short delay
  }
  setNextDisplayTime(currentTime, CLOCK_DISP_INTERVAL);
}

}
else if(displayMode == DISPLAY_MODE_EMERGENCY_MSG) {
if(findNextEmerMessage()) {
drawEmergency();
emgCurDisp++;
if(emgCurDisp >= EMG_COUNT_MAX) {
emgCurDisp = 0;
startMessageMode();
}
setNextDisplayTime(currentTime, EMERGENCY_DISP_INTERVAL);
}
// There's no message left to display. Go to normal message mode.
else {
startMessageMode();
//setPageChangeTime(0);
setNextDisplayTime(currentTime, 0); // with no re-draw interval
}
}
else if(displayMode == DISPLAY_MODE_NORMAL_MSG) {
if(findNextNormalMessage()) {
drawMessage();
msgCurDisp++;
if(msgCurDisp >= MSG_COUNT_MAX) {
msgCurDisp = 0;
startClockMode();
}
setNextDisplayTime(currentTime, MESSAGE_DISP_INTERVAL);
}
// There's no message left to display. Go to clock mode.
else {
startClockMode();
setPageChangeTime(currentTime);
setNextDisplayTime(currentTime, 0); // with no re-draw interval
}
}
else if(displayMode == DISPLAY_MODE_IDLE) {
if(isClicked == LOW) { // Wake up watch if there's an user input
startClockMode();
setPageChangeTime(currentTime);
setNextDisplayTime(currentTime, 0);
}
else {
drawIdleClock();
setNextDisplayTime(currentTime, IDLE_DISP_INTERVAL);
}
}
else {
startClockMode(); // This means there's an error
}

isClicked = HIGH;
} // End of onDraw()

// To avoid re-draw on every drawing time
// wait for time interval according to current mode
// But user input(button) breaks this sleep
boolean isDisplayTime(unsigned long currentTime) {
if(currentTime - prevDisplayTime > next_display_interval) {
return true;
}
if(isClicked == LOW) {
delay(500);
return true;
}
return false;
}

// Set next re-draw time
void setNextDisplayTime(unsigned long currentTime, unsigned long nextUpdateTime) {
next_display_interval = nextUpdateTime;
prevDisplayTime = currentTime;
}

// Decide if it's the time to change page(mode)
boolean isPageChangeTime(unsigned long currentTime) {
if(displayMode == DISPLAY_MODE_CLOCK) {
if(currentTime - mode_change_timer > CLOCK_DISPLAY_TIME)
return true;
}
return false;
}

// Set time interval to next page(mode)
void setPageChangeTime(unsigned long currentTime) {
mode_change_timer = currentTime;
}

// Check if available emergency message exists or not
boolean findNextEmerMessage() {
if(emgCurDisp < 0 || emgCurDisp >= EMG_COUNT_MAX) emgCurDisp = 0;
while(true) {
if(emgBuffer[emgCurDisp][0] == 0x00) { // 0x00 means disabled
emgCurDisp++;
if(emgCurDisp >= EMG_COUNT_MAX) {
emgCurDisp = 0;
return false;
}
}
else {
break;
}
} // End of while()
return true;
}

// Check if available normal message exists or not
boolean findNextNormalMessage() {
if(msgCurDisp < 0 || msgCurDisp >= MSG_COUNT_MAX) msgCurDisp = 0;
while(true) {
if(msgBuffer[msgCurDisp][0] == 0x00) {
msgCurDisp++;
if(msgCurDisp >= MSG_COUNT_MAX) {
msgCurDisp = 0;
return false;
}
}
else {
break;
}
} // End of while()
return true;
}

// Count all available emergency messages
int countEmergency() {
int count = 0;
for(int i=0; i<EMG_COUNT_MAX; i++) {
if(emgBuffer[i][0] != 0x00)
count++;
}
return count;
}

// Count all available normal messages
int countMessage() {
int count = 0;
for(int i=0; i<MSG_COUNT_MAX; i++) {
if(msgBuffer[i][0] != 0x00)
count++;
}
return count;
}

void startClockMode() {
displayMode = DISPLAY_MODE_CLOCK;
}

void startEmergencyMode() {
displayMode = DISPLAY_MODE_EMERGENCY_MSG;
emgCurDisp = 0;
}

void startMessageMode() {
displayMode = DISPLAY_MODE_NORMAL_MSG;
msgCurDisp = 0;
}

void startIdleMode() {
displayMode = DISPLAY_MODE_IDLE;
}

// Draw indicator. Indicator shows count of emergency and normal message
void drawIndicator() {
if(updateIndicator) {
int msgCount = countMessage();
int emgCount = countEmergency();
int drawCount = 1;

if(msgCount > 0) {
  display.drawBitmap(127 - 8, 1, IMG_indicator_msg, 8, 8, WHITE);
  display.setTextColor(WHITE);
  display.setTextSize(1);
  display.setCursor(127 - 15, 1);
  display.print(msgCount);
  drawCount++;
}

if(emgCount > 0) {
  display.drawBitmap(127 - 8*drawCount - 7*(drawCount-1), 1, IMG_indicator_emg, 8, 8, WHITE);
  display.setTextColor(WHITE);
  display.setTextSize(1);
  display.setCursor(127 - 8*drawCount - 7*drawCount, 1);
  display.print(emgCount);
}

}
}

// RetroWatch splash screen
void drawStartUp() {
display.clearDisplay();

display.drawBitmap(10, 15, IMG_logo_24x24, 24, 24, WHITE);

display.setTextSize(2);
display.setTextColor(WHITE);
display.setCursor(45,12);
display.println("Retro");
display.setCursor(45,28);
display.println("Watch");
display.setTextSize(1);
display.setCursor(45,45);
display.setTextColor(WHITE);
display.println("Arduino v1.0");
display.display();
delay(2000);

startClockMode();
}

// Draw emergency message page
void drawEmergency() {
int icon_num = 60;
display.clearDisplay();

if(updateIndicator)
drawIndicator();

if(emgBuffer[emgCurDisp][2] > -1 && emgBuffer[emgCurDisp][2] < ICON_ARRAY_SIZE)
icon_num = (int)(emgBuffer[emgCurDisp][2]);

drawIcon(centerX - 8, centerY - 20, icon_num);

display.setTextColor(WHITE);
display.setTextSize(1);
display.setCursor(getCenterAlignedXOfEmg(emgCurDisp), centerY + 10);
for(int i=3; i<EMG_BUFFER_MAX; i++) {
char curChar = emgBuffer[emgCurDisp][i];
if(curChar == 0x00) break;
if(curChar >= 0xf0) continue;
display.write(curChar);
}

display.display();
}

// Draw normal message page
void drawMessage() {
int icon_num = 0;
display.clearDisplay();

if(updateIndicator)
drawIndicator();

if(msgBuffer[msgCurDisp][2] > -1 && msgBuffer[msgCurDisp][2] < ICON_ARRAY_SIZE)
icon_num = (int)(msgBuffer[msgCurDisp][2]);

drawIcon(centerX - 8, centerY - 20, icon_num);

display.setTextColor(WHITE);
display.setTextSize(1);
display.setCursor(getCenterAlignedXOfMsg(msgCurDisp), centerY + 10);
// display.print(msgCurDisp); // For debug
for(int i=3; i<MSG_BUFFER_MAX; i++) {
char curChar = msgBuffer[msgCurDisp][i];
if(curChar == 0x00) break;
if(curChar >= 0xf0) continue;
display.write(curChar);
}

display.display();
}

// Draw main clock screen
// Clock style changes according to user selection
void drawClock() {
display.clearDisplay();

if(updateIndicator)
drawIndicator();

// CLOCK_STYLE_SIMPLE_DIGIT
if(clockStyle == CLOCK_STYLE_SIMPLE_DIGIT) {
display.setTextSize(2);
display.setTextColor(WHITE);
display.setCursor(centerX - 34, centerY - 17);
display.println((const char*)pgm_read_word(&(weekString[iWeek])));
display.setTextSize(2);
display.setCursor(centerX + 11, centerY - 17);
display.println((const char*)pgm_read_word(&(ampmString[iAmPm])));

display.setTextSize(2);
display.setCursor(centerX - 29, centerY + 6);
if(iHour < 10)
  display.print("0");
display.print(iHour);
display.print(":");
if(iMinutes < 10)
  display.print("0");
display.println(iMinutes);

display.display();

}
// CLOCK_STYLE_SIMPLE_MIX
else if(clockStyle == CLOCK_STYLE_SIMPLE_MIX) {
display.drawCircle(centerY, centerY, iRadius - 6, WHITE);
showTimePin(centerY, centerY, 0.1, 0.4, iHour5 + (int)(iMinutes5/60));
showTimePin(centerY, centerY, 0.1, 0.70, iMinutes);

display.setTextSize(1);
display.setTextColor(WHITE);
display.setCursor(centerY*2 + 3, 23);
display.println((const char*)pgm_read_word(&(weekString[iWeek])));
display.setCursor(centerY*2 + 28, 23);
display.println((const char*)pgm_read_word(&(ampmString[iAmPm])));

display.setTextSize(2);
display.setCursor(centerY*2, 37);
if(iHour < 10)
  display.print("0");
display.print(iHour);
display.print(":");
if(iMinutes < 10)
  display.print("0");
display.println(iMinutes);
display.display();

}
else {
// CLOCK_STYLE_SIMPLE_ANALOG.
display.drawCircle(centerX, centerY, iRadius, WHITE);
showTimePin(centerX, centerY, 0.1, 0.5, iHour5 + (int)(iMinutes5/60));
showTimePin(centerX, centerY, 0.1, 0.78, iMinutes);
// showTimePin(centerX, centerY, 0.1, 0.9, iSecond);
display.display();

iSecond++;
if(iSecond > 60) iSecond = 0;

}
}

// Draw idle page
void drawIdleClock() {
display.clearDisplay();

if(updateIndicator)
  drawIndicator();

display.setTextSize(2);
display.setCursor(centerX - 29, centerY - 4);
if(iHour < 10)
  display.print("0");
display.print(iHour);
display.print(":");
if(iMinutes < 10)
  display.print("0");
display.println(iMinutes);

display.display();

}

// Returns starting point of normal string to display
int getCenterAlignedXOfMsg(int msgIndex) {
int pointX = centerX;
for(int i=3; i<MSG_BUFFER_MAX; i++) {
char curChar = msgBuffer[msgIndex][i];
if(curChar == 0x00) break;
if(curChar >= 0xf0) continue;
pointX -= 3;
}
if(pointX < 0) pointX = 0;
return pointX;
}

// Returns starting point of emergency string to display
int getCenterAlignedXOfEmg(int emgIndex) {
int pointX = centerX;
for(int i=3; i<EMG_BUFFER_MAX; i++) {
char curChar = emgBuffer[emgIndex][i];
if(curChar == 0x00) break;
if(curChar >= 0xf0) continue;
pointX -= 3;
}
if(pointX < 0) pointX = 0;
return pointX;
}

// Calculate clock pin position
double RAD=3.141592/180;
double LR = 89.99;
void showTimePin(int center_x, int center_y, double pl1, double pl2, double pl3) {
double x1, x2, y1, y2;
x1 = center_x + (iRadius * pl1) * cos((6 * pl3 + LR) * RAD);
y1 = center_y + (iRadius * pl1) * sin((6 * pl3 + LR) * RAD);
x2 = center_x + (iRadius * pl2) * cos((6 * pl3 - LR) * RAD);
y2 = center_y + (iRadius * pl2) * sin((6 * pl3 - LR) * RAD);

display.drawLine((int)x1, (int)y1, (int)x2, (int)y2, WHITE);
}

// Icon drawing tool
void drawIcon(int posx, int posy, int icon_num) {
if(icon_num < 0 || icon_num >= ICON_ARRAY_SIZE)
return;

display.drawBitmap(posx, posy, (const unsigned char*)pgm_read_word(&(bitmap_array[icon_num])), 16, 16, WHITE);
}

The error iam getting is

Arduino: 1.8.14 (Windows 10), Board: "Arduino Uno"

In file included from C:\Users\user\AppData\Local\Temp\Temp3_retrowatch-master.zip\retrowatch-master\RetroWatch_Arduino\RetroWatchArduino_no_button\RetroWatchArduino_no_button.ino:35:0:

E:\Arduino\libraries\Bitmap/bitmap.h:4:10: fatal error: string: No such file or directory

#include

      ^~~~~~~~

compilation terminated.

exit status 1

Error compiling for board Arduino Uno.

This report would have more information with
"Show verbose output during compilation"
option enabled in File -> Preferences.