// Service 01 PIDs (more detail: https://en.wikipedia.org/wiki/OBD-II_PIDs)
#define PID_ENGINE_LOAD 0x04
#define PID_COOLANT_TEMP 0x05
#define PID_SHORT_TERM_FUEL_TRIM_1 0x06
#define PID_LONG_TERM_FUEL_TRIM_1 0x07
#define PID_SHORT_TERM_FUEL_TRIM_2 0x08
#define PID_LONG_TERM_FUEL_TRIM_2 0x09
#define PID_FUEL_PRESSURE 0x0A
#define PID_INTAKE_MAP 0x0B
#define PID_ENGINE_RPM  0x0C
#define PID_VEHICLE_SPEED 0x0D
#define PID_TIMING_ADVANCE 0x0E
#define PID_INTAKE_TEMP 0x0F
#define PID_MAF_FLOW 0x10
#define PID_THROTTLE 0x11
#define PID_AUX_INPUT 0x1E
#define PID_RUNTIME 0x1F
#define PID_DISTANCE_WITH_MIL 0x21
#define PID_COMMANDED_EGR 0x2C
#define PID_EGR_ERROR 0x2D
#define PID_COMMANDED_EVAPORATIVE_PURGE 0x2E
#define PID_FUEL_LEVEL 0x2F
#define PID_WARMS_UPS 0x30
#define PID_DISTANCE 0x31
#define PID_EVAP_SYS_VAPOR_PRESSURE 0x32
#define PID_BAROMETRIC 0x33
#define PID_CATALYST_TEMP_B1S1 0x3C
#define PID_CATALYST_TEMP_B2S1 0x3D
#define PID_CATALYST_TEMP_B1S2 0x3E
#define PID_CATALYST_TEMP_B2S2 0x3F
#define PID_CONTROL_MODULE_VOLTAGE 0x42
#define PID_ABSOLUTE_ENGINE_LOAD 0x43
#define PID_AIR_FUEL_EQUIV_RATIO 0x44
#define PID_RELATIVE_THROTTLE_POS 0x45
#define PID_AMBIENT_TEMP 0x46
#define PID_ABSOLUTE_THROTTLE_POS_B 0x47
#define PID_ABSOLUTE_THROTTLE_POS_C 0x48
#define PID_ACC_PEDAL_POS_D 0x49
#define PID_ACC_PEDAL_POS_E 0x4A
#define PID_ACC_PEDAL_POS_F 0x4B
#define PID_COMMANDED_THROTTLE_ACTUATOR 0x4C
#define PID_TIME_WITH_MIL 0x4D
#define PID_TIME_SINCE_CODES_CLEARED 0x4E
#define PID_ETHANOL_FUEL 0x52
#define PID_FUEL_RAIL_PRESSURE 0x59
#define PID_HYBRID_BATTERY_PERCENTAGE 0x5B
#define PID_ENGINE_OIL_TEMP 0x5C
#define PID_FUEL_INJECTION_TIMING 0x5D
#define PID_ENGINE_FUEL_RATE 0x5E
#define PID_ENGINE_TORQUE_DEMANDED 0x61
#define PID_ENGINE_TORQUE_PERCENTAGE 0x62
#define PID_ENGINE_REF_TORQUE 0x63
//----------------------------------------------

#define CAN_ID_PID 0x7DF //OBD-II CAN frame ID

#include <mcp_can.h>
#include <SPI.h>
#define CAN0_INT 2                              // Set INT to pin 2  <--------- CHANGE if using different pin number
MCP_CAN CAN0(10);                               // Set CS to pin 10 <--------- CHANGE if using different pin number

long unsigned int rxId;
unsigned char len = 0;
unsigned char rxBuf[8];
char msgString[128];                        // Array to store serial string

//ddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddd
#include <SPI.h>
#include <Wire.h>
#include <Adafruit_GFX.h>
#include <Adafruit_SSD1306.h>
#include <Fonts/FreeSansBold18pt7b.h>
#include <Fonts/FreeMonoBold9pt7b.h>


#define SCREEN_WIDTH 128 // OLED display width, in pixels
#define SCREEN_HEIGHT 32 // OLED display height, in pixels
Adafruit_SSD1306 display(SCREEN_WIDTH, SCREEN_HEIGHT, &Wire, -1);
//ddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddd
//ddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddd
#define arduino_HEIGHT   32
#define arduino_WIDTH    60
const unsigned char PROGMEM arduino [] = {
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0f, 0xff, 0xff, 0x00, 0x00, 0x00, 
	0x00, 0x00, 0xff, 0xff, 0xff, 0xf0, 0x00, 0x00, 0x00, 0x07, 0xff, 0xf0, 0x07, 0xfe, 0x00, 0x00, 
	0x00, 0x3f, 0xcf, 0xe0, 0x00, 0x3f, 0x80, 0x00, 0x00, 0x7c, 0x0f, 0xc0, 0x00, 0x07, 0xe0, 0x00, 
	0x01, 0xf0, 0x1f, 0x80, 0x00, 0x0f, 0xf8, 0x00, 0x03, 0xc0, 0x3f, 0x80, 0x00, 0x1f, 0xfc, 0x00, 
	0x0f, 0x00, 0x3f, 0x00, 0x00, 0x3f, 0xcf, 0x00, 0x1e, 0x00, 0x7f, 0x00, 0x00, 0xff, 0x87, 0x80, 
	0x1c, 0x00, 0xff, 0x00, 0x07, 0xff, 0x83, 0x80, 0x38, 0x00, 0xff, 0x00, 0x1f, 0xff, 0x81, 0xc0, 
	0x30, 0x01, 0xff, 0x00, 0xff, 0xff, 0x00, 0xc0, 0x70, 0x03, 0xff, 0x87, 0xff, 0xff, 0x00, 0xe0, 
	0x60, 0x03, 0xff, 0xff, 0xff, 0xfe, 0x00, 0xe0, 0x60, 0x07, 0xff, 0xff, 0xff, 0xfe, 0x00, 0x60, 
	0x60, 0x07, 0xff, 0xff, 0xff, 0xfc, 0x00, 0x60, 0x70, 0x0f, 0xff, 0xff, 0x3f, 0xfc, 0x00, 0xe0, 
	0x70, 0x0f, 0xff, 0xf0, 0x0f, 0xf8, 0x00, 0xc0, 0x38, 0x1f, 0xff, 0x80, 0x0f, 0xf0, 0x01, 0xc0, 
	0x1c, 0x1f, 0xfe, 0x00, 0x0f, 0xf0, 0x03, 0x80, 0x1e, 0x1f, 0xf8, 0x00, 0x0f, 0xe0, 0x07, 0x80, 
	0x0f, 0x3f, 0xe0, 0x00, 0x0f, 0xe0, 0x0f, 0x00, 0x07, 0xff, 0x80, 0x00, 0x1f, 0xc0, 0x1e, 0x00, 
	0x01, 0xff, 0x00, 0x00, 0x1f, 0x80, 0x78, 0x00, 0x00, 0xfe, 0x00, 0x00, 0x3f, 0x03, 0xf0, 0x00, 
	0x00, 0x3f, 0x80, 0x00, 0x3f, 0x1f, 0xc0, 0x00, 0x00, 0x0f, 0xfc, 0x00, 0x7f, 0xff, 0x00, 0x00, 
	0x00, 0x01, 0xff, 0xff, 0xff, 0xf8, 0x00, 0x00, 0x00, 0x00, 0x1f, 0xff, 0xff, 0x80, 0x00, 0x00, 
	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
};



// 'coolant', 46x32px
#define coolant_HEIGHT   32
#define coolant_WIDTH    46
const unsigned char coolant [] PROGMEM = {
	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
	0x3f, 0x80, 0x00, 0x00, 0x00, 0x00, 0x7f, 0xe0, 0x00, 0x00, 0x00, 0x00, 0x7f, 0xe0, 0x00, 0x00, 
	0x00, 0x00, 0xf0, 0xf0, 0x00, 0x00, 0x00, 0x00, 0xe6, 0x3c, 0x00, 0x00, 0x00, 0x00, 0xef, 0x3c, 
	0x00, 0x00, 0x00, 0x00, 0xef, 0x30, 0x00, 0x00, 0x00, 0x00, 0xef, 0x30, 0x00, 0x00, 0x00, 0x00, 
	0xef, 0x3c, 0x66, 0x32, 0x19, 0x2e, 0xef, 0x3c, 0x89, 0x4a, 0x25, 0xa4, 0xef, 0x30, 0x89, 0x4a, 
	0x3d, 0xe4, 0xef, 0x30, 0x89, 0x4a, 0x25, 0x64, 0xef, 0x3c, 0x66, 0x33, 0xa5, 0x24, 0xef, 0x3c, 
	0x00, 0x00, 0x00, 0x00, 0xef, 0x30, 0xff, 0x7d, 0x8d, 0xf1, 0xef, 0x38, 0xff, 0x7d, 0xdd, 0xfb, 
	0xef, 0x78, 0x18, 0x61, 0xfd, 0x9b, 0x8f, 0x3c, 0x18, 0x79, 0xfd, 0xfb, 0x9f, 0x9c, 0x18, 0x79, 
	0xad, 0xf3, 0xbf, 0xdc, 0x18, 0x61, 0x8d, 0x83, 0x3f, 0xdc, 0x18, 0x7d, 0x8d, 0x83, 0x3f, 0xdc, 
	0x18, 0x7d, 0x8d, 0x83, 0xbf, 0xdc, 0x00, 0x00, 0x00, 0x03, 0x9f, 0x9c, 0x00, 0x00, 0x00, 0x03, 
	0xcf, 0x38, 0x00, 0x00, 0x00, 0x01, 0xe0, 0x78, 0x00, 0x00, 0x00, 0x01, 0xff, 0xf0, 0x00, 0x00, 
	0x00, 0x00, 0x7f, 0xe0, 0x00, 0x00, 0x00, 0x00, 0x1f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
};

// 'warning', 30x29px
#define warning_HEIGHT   29
#define warning_WIDTH    30
const unsigned char warning[] PROGMEM = {
	0x00, 0x0f, 0xc0, 0x00, 0x00, 0x0f, 0xe0, 0x00, 0x00, 0x1f, 0xe0, 0x00, 0x00, 0x1f, 0xf0, 0x00, 
	0x00, 0x3f, 0xf0, 0x00, 0x00, 0x7f, 0xf8, 0x00, 0x00, 0x7f, 0xf8, 0x00, 0x00, 0xff, 0xfc, 0x00, 
	0x00, 0xff, 0xfc, 0x00, 0x01, 0xff, 0xfe, 0x00, 0x01, 0xfc, 0xfe, 0x00, 0x03, 0xfc, 0xff, 0x00, 
	0x03, 0xfc, 0xff, 0x00, 0x07, 0xfc, 0xff, 0x80, 0x07, 0xfc, 0xff, 0x80, 0x0f, 0xf8, 0xff, 0xc0, 
	0x0f, 0xf8, 0xff, 0xc0, 0x1f, 0xf8, 0xff, 0xe0, 0x1f, 0xff, 0xff, 0xe0, 0x3f, 0xff, 0xff, 0xf0, 
	0x3f, 0xff, 0xff, 0xf0, 0x7f, 0xfc, 0xff, 0xf8, 0x7f, 0xfc, 0xff, 0xf8, 0xff, 0xfc, 0xff, 0xfc, 
	0xff, 0xff, 0xff, 0xfc, 0xff, 0xff, 0xff, 0xfc, 0xff, 0xff, 0xff, 0xfc, 0xff, 0xff, 0xff, 0xfc, 
	0xff, 0xff, 0xff, 0xfc
};

// 'rpm', 42x32px
#define rpm_gosterge_HEIGHT   32
#define rpm_gosterge_WIDTH    42
const unsigned char rpm_gosterge [] PROGMEM = {
	0x00, 0x00, 0x7f, 0xc0, 0x00, 0x00, 0x00, 0x03, 0xff, 0xf8, 0x00, 0x00, 0x00, 0x1f, 0x8c, 0x3f, 
	0x00, 0x00, 0x00, 0x3c, 0x0d, 0x87, 0x80, 0x00, 0x00, 0xf0, 0x03, 0x81, 0xe0, 0x00, 0x01, 0xde, 
	0x07, 0x80, 0x70, 0x00, 0x03, 0xfb, 0x0f, 0x80, 0xf8, 0x00, 0x07, 0x63, 0x0f, 0xc1, 0x9c, 0x00, 
	0x0e, 0x2f, 0x01, 0x87, 0xee, 0x00, 0x0c, 0x03, 0x01, 0x87, 0x06, 0x00, 0x18, 0x3b, 0x00, 0x07, 
	0xe3, 0x00, 0x38, 0x1e, 0x00, 0x00, 0x63, 0x80, 0x30, 0x00, 0x00, 0x00, 0x61, 0x80, 0x77, 0x80, 
	0x00, 0x07, 0xe1, 0xc0, 0x6e, 0xc0, 0x00, 0x00, 0x00, 0xc0, 0x78, 0xdf, 0xc7, 0xf1, 0xe3, 0xc0, 
	0x7f, 0xdf, 0xe7, 0xf9, 0xf7, 0xc0, 0xce, 0x1c, 0x77, 0x1d, 0xff, 0xc0, 0xce, 0x1c, 0x77, 0x1d, 
	0xff, 0xc0, 0xcf, 0xdf, 0xe7, 0xf9, 0xdd, 0xc0, 0xc0, 0x1f, 0xc7, 0xf1, 0xc9, 0xc0, 0xc0, 0x1f, 
	0x07, 0x01, 0xc1, 0xc0, 0xc0, 0x1f, 0x87, 0x01, 0xc1, 0xc0, 0xc0, 0x1d, 0xc7, 0x01, 0xc1, 0xc0, 
	0xc3, 0x1c, 0xe7, 0x01, 0xc1, 0xc0, 0x67, 0x1c, 0x67, 0x01, 0xc1, 0xc0, 0x6f, 0x00, 0x00, 0x00, 
	0x00, 0x00, 0x7f, 0x00, 0x01, 0x98, 0xc6, 0xc0, 0x7b, 0x00, 0x14, 0xad, 0x6b, 0x80, 0x33, 0x00, 
	0x08, 0xad, 0x6b, 0x80, 0x3f, 0x80, 0x14, 0xad, 0x6b, 0x00, 0x18, 0x00, 0x00, 0x98, 0xc7, 0x00
};

// 'speed', 47x32px
#define speed_gosterge_HEIGHT   32
#define speed_gosterge_WIDTH    47
const unsigned char speed_gosterge [] PROGMEM = {
	0x00, 0x00, 0x7f, 0xc0, 0x00, 0x00, 0x00, 0x03, 0xff, 0xf8, 0x00, 0x00, 0x00, 0x1f, 0x86, 0x3f, 
	0x00, 0x00, 0x00, 0x3c, 0x02, 0x07, 0x80, 0x00, 0x00, 0xf1, 0xf8, 0xc1, 0xe0, 0x00, 0x01, 0xc0, 
	0xed, 0x20, 0x70, 0x00, 0x03, 0xc0, 0xf9, 0x20, 0xf8, 0x00, 0x07, 0x60, 0x99, 0x21, 0x9c, 0x00, 
	0x0e, 0x20, 0xfc, 0xc0, 0x0e, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x06, 0x00, 0x18, 0xf3, 0x00, 0x63, 
	0x33, 0x00, 0x38, 0x94, 0x80, 0x25, 0x4b, 0x80, 0x30, 0xf4, 0x80, 0x29, 0x49, 0x80, 0x70, 0x14, 
	0x80, 0x2f, 0x49, 0xc0, 0x60, 0xf3, 0x00, 0x21, 0x30, 0xc0, 0x78, 0x00, 0x00, 0x00, 0x00, 0x00, 
	0x78, 0x00, 0x00, 0x00, 0x00, 0xc0, 0xc3, 0x98, 0x79, 0xf7, 0xfe, 0xfe, 0xf4, 0xa4, 0xfd, 0xff, 
	0xff, 0xfe, 0xe7, 0xa4, 0xcd, 0x9f, 0x18, 0xe6, 0xc4, 0xa4, 0xf9, 0xff, 0xde, 0xe6, 0xc7, 0x98, 
	0x7d, 0xff, 0xde, 0xe6, 0xc0, 0x00, 0x7d, 0xf7, 0xde, 0xe6, 0xc0, 0x00, 0xcd, 0x87, 0x18, 0xe6, 
	0xc0, 0x00, 0xfd, 0x87, 0xde, 0xfe, 0x61, 0xcc, 0xfd, 0x87, 0xde, 0xfe, 0x6e, 0x52, 0x00, 0x00, 
	0x00, 0x00, 0x7d, 0x92, 0x00, 0x36, 0xc6, 0xd8, 0x7a, 0x52, 0x00, 0x3c, 0xef, 0xd8, 0x31, 0xcc, 
	0x00, 0x38, 0xff, 0xf8, 0x38, 0x00, 0x00, 0x3c, 0xd7, 0xf8, 0x18, 0x00, 0x00, 0x36, 0xc7, 0xd8
};

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

uint32_t rpm = 0;
//ddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddd

// BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB
#define BUTTON_UP_PIN 7 // pin for UP button 
#define BUTTON_SELECT_PIN 4 // pin for SELECT button
#define BUTTON_DOWN_PIN 8 // pin for DOWN button

// BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB
void sendPID(unsigned char __pid)
{
  unsigned char tmp[8] = {0x02, 0x01, __pid, 0, 0, 0, 0, 0};

  byte sndStat = CAN0.sendMsgBuf(CAN_ID_PID, 0, 8, tmp);

  if (sndStat == CAN_OK) {
    Serial.print("PID sent: 0x");
    Serial.println(__pid, HEX);
  }
  else {
   Serial.println("Error Sending Message...");
   msg_("Error Snd \n Msg!");
   //delay(2000); 
   //display.clearDisplay();///ekran temizleniyor
  }
}

void receivePID(unsigned char __pid)
{
    if (!digitalRead(CAN0_INT)) {                      // If CAN0_INT pin is low, read receive buffer
    CAN0.readMsgBuf(&rxId, &len, rxBuf);      // Read data: len = data length, buf = data byte(s)

    sprintf(msgString, "Standard ID: 0x%.3lX, DLC: %1d, Data: ", rxId, len);
    Serial.print(msgString);

    for (byte i = 0; i < len; i++) {
      sprintf(msgString, " 0x%.2X", rxBuf[i]);
      Serial.print(msgString);
    }
    Serial.println("");


    switch (__pid) {
      case PID_COOLANT_TEMP:
        if(rxBuf[2] == PID_COOLANT_TEMP){
          uint8_t temp;
          temp = rxBuf[3] - 40;
          Serial.print("Engine Coolant Temp (degC): ");
          Serial.println(temp, DEC);

          hararet(temp);
          if (temp>120)
          {
            warn();
          }
          
        }
      break;

      case PID_ENGINE_RPM:
        if(rxBuf[2] == PID_ENGINE_RPM){
          uint16_t rpm;
          rpm = ((256 * rxBuf[3]) + rxBuf[4]) / 4;
          Serial.print("Engine Speed (rpm): ");
          Serial.println(rpm, DEC);
          RPM(rpm);
        }
      break;
      
      case PID_VEHICLE_SPEED:
        if(rxBuf[2] == PID_VEHICLE_SPEED){
          uint16_t spd;
          spd = (rxBuf[3]);
          Serial.print("Engine Speed (km/h): ");
          Serial.println(spd, DEC);
          Speed(spd);
        }
      break;
    }
  }
}

int menu_item=0;

void setup()
{
  Serial.begin(115200);

  // Initialize MCP2515 running at 16MHz with a baudrate of 500kb/s and the masks and filters disabled.
  if (CAN0.begin(MCP_STDEXT, CAN_500KBPS, MCP_8MHZ) == CAN_OK) { //< -------- - CHANGE if using different board
    Serial.println("MCP2515 Initialized Successfully!");
  }
  else {
    //Serial.println("Error Initializing MCP2515...");
    while (1);
  }

  //initialise mask and filter to allow only receipt of 0x7xx CAN IDs
  CAN0.init_Mask(0, 0, 0x07000000);              // Init first mask...
  CAN0.init_Mask(1, 0, 0x07000000);              // Init second mask...

  
  for (uint8_t i = 0; i < 6; ++i) {
    CAN0.init_Filt(i, 0, 0x07000000);           //Init filters
  }
  
  CAN0.setMode(MCP_NORMAL);                     // Set operation mode to normal so the MCP2515 sends acks to received data.

  pinMode(CAN0_INT, INPUT);                    // Configuring pin for /INT input

  Serial.println("Sending and Receiving OBD-II_PIDs Example...");




// BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB
  
  pinMode(BUTTON_UP_PIN, INPUT_PULLUP); // up button
  pinMode(BUTTON_SELECT_PIN, INPUT_PULLUP); // select button
  pinMode(BUTTON_DOWN_PIN, INPUT_PULLUP); // down button

// BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB

//ddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddd
  if(!display.begin(SSD1306_SWITCHCAPVCC, 0x3C)) { 
    Serial.println("SSD1306 allocation failed");
    for(;;);
  }
testdrawbitmap();
//ddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddd

}


void loop()
{

  if(digitalRead(BUTTON_UP_PIN)==LOW){
  menu_item++;
  delay(500);
  }

  if(digitalRead(BUTTON_SELECT_PIN)==LOW){
  menu_item=0;
  Serial.println("SELECT");
  delay(500);
  }

  if(digitalRead(BUTTON_DOWN_PIN)==LOW){
  menu_item--;
  delay(500);
  }

 if (menu_item>2){menu_item=0;}
  if (menu_item<0){menu_item=2;}
  Serial.println("menu_item=");
  Serial.println(menu_item);

  if (menu_item==0){
  //request coolant temp
  sendPID(PID_COOLANT_TEMP);
  delay(40); //to allow time for ECU to reply
  receivePID(PID_COOLANT_TEMP);
  //hararet(120);
  }else if(menu_item==1){
  //request engine speed
  sendPID (PID_ENGINE_RPM);
  delay(40); //to allow time for ECU to reply
  receivePID(PID_ENGINE_RPM);  
  //RPM(3500);
  }else if (menu_item==2){
  sendPID (PID_VEHICLE_SPEED);
  delay(40); //to allow time for ECU to reply
  receivePID(PID_VEHICLE_SPEED);  
  //Speed(140);
  } 
 
}

void testdrawbitmap(void) {
 for(int i=-32; i<1; i+=1) {
  display.clearDisplay();
  display.drawBitmap(
    (display.width() - arduino_WIDTH ) / 2,i,arduino, arduino_WIDTH, arduino_HEIGHT, 1);
  display.display();
  delay(10); /// Hız
  }
  delay(3000); // Ekranda bekleme
}

void hararet(int hrr){ // 
  display.setFont(&FreeSansBold18pt7b);
  display.clearDisplay();
  display.setTextSize(1);      // Normal 1:1 pixel scale
  display.setTextColor(SSD1306_WHITE); // Draw white text
  display.drawBitmap(0,0,coolant, coolant_WIDTH, coolant_HEIGHT, 1);
  display.setCursor(50, 27);     // Start at top-left corner
  display.print(hrr);
  /*
  if(hrr>110){
  display.clearDisplay();
  display.setTextSize(1);      // Normal 1:1 pixel scale
  display.setTextColor(SSD1306_WHITE); // Draw white text
  display.drawBitmap((display.width() - 30)/2,1,warning, warning_WIDTH, warning_HEIGHT, 1);  
  }
  */
  display.display();
  }


void RPM(int hrr){ // 
  display.setFont(&FreeSansBold18pt7b);
  display.clearDisplay();
  display.setTextSize(1);      // Normal 1:1 pixel scale
  display.setTextColor(SSD1306_WHITE); // Draw white text
  display.drawBitmap(0,0,rpm_gosterge, rpm_gosterge_WIDTH, rpm_gosterge_HEIGHT, 1);
  display.setCursor(50, 27);     // Start at top-left corner
  display.print(hrr);
  display.display();
  }

void Speed(int hrr){ // 
  display.setFont(&FreeSansBold18pt7b);
  display.clearDisplay();
  display.setTextSize(1);      // Normal 1:1 pixel scale
  display.setTextColor(SSD1306_WHITE); // Draw white text
  display.drawBitmap(0,0,speed_gosterge, speed_gosterge_WIDTH, speed_gosterge_HEIGHT, 1);
  display.setCursor(50, 27);     // Start at top-left corner
  display.print(hrr);
  display.display();
  }

void warn(){
 // display.clearDisplay();
  display.setTextSize(1);      // Normal 1:1 pixel scale
  display.setTextColor(SSD1306_WHITE); // Draw white text
  display.drawBitmap(100,1,warning, warning_WIDTH, warning_HEIGHT, 1);
  display.display();
}

void msg_(String msgg){ // 
  display.setFont(&FreeMonoBold9pt7b);
  display.clearDisplay();
  display.setTextSize(1);      // Normal 1:1 pixel scale
  display.setTextColor(SSD1306_WHITE); // Draw white text
  display.setCursor(0, 12);     // Start at top-left corner
  display.print(msgg);
  display.display();
  }
