Мужики не могу найти ссылку на библиотеку TimeHelpers от автора Leshak.

Спасибо за помощь

Попробуй здесь. Или спроси у автора, ссылка в теме есть.

https://bitbucket.org/alxarduino/leshakutils/downloads

В самом начале, я в статье выражал благодарность автору библиотеки

Большое спасибо участнику форума Leshak за представленную библиотеку работы с функцией времениhttp://alxarduino.blogspot.ru/2013/08/delay.html.

Рад что тема, предложенная  Sergey_Ch не завяла. Из за загруженности на работе("даём тепло и радость" людям), редко заглядываю на форум. К тому же опять задерживается посылка из Китая с 3.3В Ардуинкой и датчиками. Сборка, описанная в 38п. (на NANO) функционирует не выключаясь с времени описания. Погодозависимые окружающие благодарны. Переделывать на батарейное питание и дорабатывать код буду по прибытии посылки с востока.

......Если есть возможность оптимизировать энергопотребление......

Про мини 3,3V ....  Потребляемый ток 1,7мА......  После "поднятия" резистора светодиода с платы ("питание" не светится) - 0,3мА. Сейчас поищу другой тестер - попробую замерить точнее.... АКБ подключен к RAW (к внутреннему стабилизатору).

0,362мА 

Привет! Видимо туплю - не могу разобраться как сделать в данном примере например 3 экрана: сначала отдельно текущее давление, потом отдельно температуру, а потом график изменения давления. В будущем наверно еще и с датчика влажности отдельно хочется значение и график повесить. Переменную cnt увеличить, например до 4, и последовательно перебрать: 

 if (count1 == CNT){действие 1}

    else if (count1 == CNT-1){действие 2}

         else if (count1 == CNT-2){действие 3}

Но как тогда выставить время между действиями?Помогите пожалуйста разобраться.

Если кого то заинтересует - будет тема с кодом и фотками в субботу - воскресенье.

Ждем - ждем, воскресенья проходят, а кода и фото все нет!(( Очень хотелось бы!

Уважаемые коллеги!!! На форуме кучи разных наработок с незаконченными до конца кодами, можете кто выложить нормальный, отлаженный код, достаточно прокомментирован, с такими возможностями: в коде можно внести коррекцию по высоте над уровнем моря, интервал вывода столбцов. Сохранение данных в EEPROM. На экране только текущее отображение давления с точностью до десятых. Схемма подключения дисплея и датчика. Буду очень благодарен!

Если кого то заинтересует - будет тема с кодом и фотками в субботу - воскресенье.

Ждем - ждем, воскресенья проходят, а кода и фото все нет!(( Очень хотелось бы!

Прошу прощения ..... Очень редко тут бываю . 

Код писался до освоения функций и массивов .......  Переделывать сейчас времени нету ...... 

Когда будет полегче на работе перепишу под 3,5 дюймовый TFT (совсем слепой стал) с использованием масивов, EEPROM и т.д. в пределах освоенного ..... 

   
   //////////// БИБЛИОТЕКИ //////////
   #include <Adafruit_GFX.h>    
   #include <Adafruit_ST7735.h> 
   #include <Adafruit_BMP085.h>
   #include <SPI.h>
   #include <Wire.h>
   #include <EEPROM.h>
   #include "DS3231.h"
   
   //////////// активизируем дисплей /////////
   #define TFT_CS     9
   #define TFT_RST    8     
   #define TFT_DC     10
   Adafruit_ST7735 tft = Adafruit_ST7735(TFT_CS,  TFT_DC, TFT_RST);
   ///////////// пробывал и так - не понравилось ///////////
   //#define TFT_SCLK 13   // set these to be whatever pins you like!
   //#define TFT_MOSI 11   // set these to be whatever pins you like!
   //Adafruit_ST7735 tft = Adafruit_ST7735(TFT_CS, TFT_DC, TFT_MOSI, TFT_SCLK, TFT_RST);
   
   /////////// активизируем датчик давления ////////////
   Adafruit_BMP085 bmp;
   
   /////////// активизируем часы ///////////
   DS3231 Clock;
   bool Century=false;
   
   //////////   ПЕРЕМЕННЫЕ   /////////////////
   
   /////////// часов ///////////
   byte year, month, date, DoW, hour, minute, second;
   int Lsecond = 0;
   
    int analogPin = 0;      //  пин входа фоторезистора с "+" , на "-" резистор ....
    int ledPin   = 6 ;      //  пин регулировки яркости  " BL "
    int Temp   = 0 ;        //  температура
    int Press  = 0 ;        //  давление
   //////////  Давление каждый час  ///////////
    byte Press0,Press1,Press2,Press3,Press4,Press5,Press6,Press7,Press8,Press9,Press10,Press11 ;
    
     //////////  Температура каждый час  ///////////
    byte Temp0, Temp1, Temp2, Temp3, Temp4, Temp5, Temp6, Temp7, Temp8, Temp9, Temp10, Temp11  ;
    
     //////////  Время каждый час  ///////////
    byte Chass0,Chass1,Chass2,Chass3,Chass4,Chass5,Chass6,Chass7,Chass8,Chass9,Chass10,Chass11  ;
    
    byte knop = 0    ;              //  кнопка
    byte PressEP    ;              //  давление из памяти 
    byte TempEP     ;              //  температура из памяти
    byte ChassEP     ;             //  часы из памяти
    byte addressP = 0;              //  адрес чтения давления 
    byte addressT = 20;             //  адрес чтения температуры  
    byte addressCH = 40;            //  адрес чтения часов
    byte chas = 0   ;              //  переменная отсчитываем 1 час
    byte Chass  = 0  ;             
    int minut = 0   ;              //  переменная отсчитываем 5 мин
    int minutX = 0  ;
    byte static prevPress=0; // тут будем хранить, какое давление было при выводе на дисплей
    byte static prevTemp=0; // тут будем хранить, температуру 
    ////////////
    
 
    /////////////
void setup(void) {
  //Serial.begin(9600);
  Wire.begin();
  bmp.begin();
  tft.initR(INITR_BLACKTAB); 
  tft.fillScreen(ST7735_BLACK);    //  дисплей цвет фона
  tft.setRotation(3);              //  повернуть по горизонту
  pinMode(2,INPUT);                //  кнопка на  пин2
  digitalWrite(2,HIGH);            //  подтягиваем к +
  
  ///////////////////////////////////////////////////
 
}

void loop() {
  /////////    стереть память  //////////
/*
EEPROM.write(addressP, 0);
EEPROM.write(addressT, 0);
EEPROM.write(addressCH, 0);
addressP = addressP + 1;          //  устанавливаем следующие адреса
addressT = addressT + 1;
addressCH = addressCH + 1;
 if (addressP = 12)  
addressP = 0  ;
if (addressT  = 32) 
 addressT  = 20 ;
if (addressCH  = 52)
 addressCH = 40 ;}
*/


/////////  при смене даты очищаем экран ////////

   byte static prevdate=0;             // тут будем хранить дату
   if(date  !=  prevdate)              // если поменялась чистим экран
   {tft.fillScreen(ST7735_BLACK);
   prevdate = date ;}
   
/////////  регулируем яркость (что бы ночью не светил как прожектор)  //////

   int val = analogRead(analogPin);    // Создаем переменную val для чтения analogRead
   val= constrain(val,50 ,799);        // устанавливаем нужные(посмотрим в Serial.print) границы переменной
   val /= 4 ;                          // 1024 преобразуем в 255
   analogWrite(ledPin,val);            // установим яркость в соотв.с освещением
      
   Clock.getTime(year, month, date, DoW, hour, minute, second);  // читаем часы
   Temp = bmp.readTemperature();      //читаем датчик
   Press = bmp.readPressure()/133.3;
   knop = digitalRead(2);           //  читаем кнопку
 
   if (knop == HIGH)                //  если не нажата  то  ПОЕХАЛИ ....

 { 
 ////////////////  дата  /////////////////////

 tft.setCursor(30, 10);           //  курсор
 tft.setTextColor(ST7735_MAGENTA);   //  цвет
 tft.setTextSize(2);              //  размер
 tft.println(date);
/////////////  месяц  ///////////////
 tft.println("  ");
 if (month ==1)
 tft.println("января");
 if (month ==2)
 tft.println("февраля");
 if (month ==3)
 tft.println("марта");
 if (month ==4)
 tft.println("апреля");
 if (month ==5)
 tft.println("мая");
 if (month ==6)
 tft.println("июня");
 if (month ==7)
 tft.println("июля");
 if (month ==8)
 tft.println("августа");
 if (month ==9)
 tft.println("сентября");
 if (month ==10)
 tft.println("октября");
 if (month ==11)
 tft.println("ноября");
 if (month ==12)
 tft.println("декабря");
 
 ///////////////  часы ////////////////////////
  
  //tft.setTextColor(ST7735_CYAN);   //  цвет
  tft.setTextSize(4);              //  размер
  byte static prevhour=0; // тут будем хранить, сколько часов было при выводе
  if(hour!=prevhour) //  если часы поменялись - стираем старые
   {
     tft.setCursor(20, 35);           //  курсор
     tft.setTextColor(ST7735_BLACK);
       if(hour<10)              
     {   tft.println("0");  }      //  если был , стираем  "0"
        tft.println(prevhour);
   }
  /////////////  и пишем новые  //////////////
     tft.setCursor(20, 35);           //  курсор
     tft.setTextColor(ST7735_CYAN);   //  цвет
     if(hour<10)
  {  tft.println("0");   }           //  если нужен, пишем "0"
     tft.println(hour);
     prevhour = hour ;
  
     /////////////////////  моргаем индикатором секунд ////////////////////////////
    byte static prevSecond=0; // тут будем хранить, сколько секунд было при выводе
    if(second!=prevSecond) //  если секунды поменялись
 {   tft.setTextSize(3);
      tft.setCursor(70, 40);    //  курсор
      if (Lsecond == 0)    // и индикатор не светится 
    ///////////  зажигаем его ////////////
    {
    tft.setTextColor(ST7735_CYAN);
    tft.println(":");
    Lsecond = 1 ;
    }
    else  //////  если светится - гасим 
    {
    tft.setTextColor(ST7735_BLACK);
    tft.println(":");
    Lsecond = 0 ;
    }
  }
    prevSecond=second; // запомнили когда мы "отчитались"
 
       ////////  минуты //////////////
  
   tft.setTextSize(4);              //шрифт
  
   byte static prevminute=0;       // тут будем хранить, сколько минут было при выводе 
   if(minute!=prevminute)          // если минуты поменялись стираем предыдущие
   {  
     tft.setCursor(90, 35);           //  курсор
     tft.setTextColor(ST7735_BLACK); 
       if(prevminute<10)
   {   tft.print("0");   }         //  если был , стираем  "0"
    tft.print(prevminute);
   }
     //////////  пишем новые  //////////
     tft.setCursor(90, 35);
     tft.setTextColor(ST7735_CYAN);   //  цвет
     if(minute<10)
  {  tft.print("0");   }       //  если нужен, пишем "0"
     tft.print(minute);
     prevminute = minute  ;   //  Запоминаем что записали
   
  
  tft.setTextColor(ST7735_RED);  //  цвет
  tft.setTextSize(2);              //  размер
  if (DoW == 1)
  {tft.setCursor(15, 75);
  tft.println("Понедельник");}
  if (DoW == 2)
  {tft.setCursor(40, 75);
  tft.println("Вторник");}
  if (DoW == 3)
  {tft.setCursor(50, 75);
  tft.println("Среда");}
  if (DoW == 4)
  {tft.setCursor(40, 75);
  tft.println("Четверг");}
  if (DoW == 5)
  {tft.setCursor(40, 75);
  tft.println("Пятница");}
  if (DoW == 6)
  {tft.setCursor(40, 75);
  tft.println("Суббота");}
  if (DoW == 7)
  {tft.setCursor(15, 75);
  tft.println("Воскресенье");}

   
////////////////   выводим давление и температуру  1 раз в 5 мин (300000 мсек) ////////////////////
  
///////////////  Давление /////////////////////////
   minut = millis() - minutX ;
  if (minut >= 5000)
  {
 
  if(Press!=prevPress) //  если давление поменялось стираем предыдущее 
  
  {
  tft.setCursor(20, 100);
  tft.setTextSize(2);
  tft.setTextColor(ST7735_BLACK);
  tft.print(prevPress);
  
 
 ///////////// и пишем настоящее /////////////
  tft.setCursor(20, 100);
  tft.setTextColor(ST7735_YELLOW);
  tft.print(Press);
  tft.println("mm");
  }
  prevPress  = Press ; // Запоминаем что записали
 
 ///////////////  температура  /////////////////////

  if(Temp!=prevTemp) //  если поменялось стираем предыдущее 
  {
  tft.setCursor(100, 100);
  tft.setTextSize(2);
  tft.setTextColor(ST7735_BLACK);
  tft.print(prevTemp); }
  
  
 ///////////// и пишем настоящее /////////////
  tft.setCursor(100, 100);
  tft.setTextColor(ST7735_YELLOW);
  tft.print(Temp);
  tft.println("*C");
  
  prevTemp  = Temp ;      // Запоминаем что записали
  minut = 0 ;
  minutX = millis() ;
  //Serial.print(hour);
}
 
 
  

   {
//////// запись давления и тепературы каждый час //////////////////
/// переписываем содержимое предыдущей ячейки в последующую начиная с предпоследней
///  в начальную записываем текущее значение
Chass  = hour ;
byte static chas=0; // тут будем хранить, сколько часов было при прошлом отчете

  if(hour  != chas) // если часы поменялись

        {
        Press10 = EEPROM.read(10);
        EEPROM.write(11, Press10);
        Press9 = EEPROM.read(9);
        EEPROM.write(10, Press9);
        Press8 = EEPROM.read(8);
        EEPROM.write(9, Press8);
        Press7 = EEPROM.read(7);
        EEPROM.write(8, Press7);
        Press6 = EEPROM.read(6);
        EEPROM.write(7, Press6);
        Press5 = EEPROM.read(5);
        EEPROM.write(6, Press5);
        Press4 = EEPROM.read(4);
        EEPROM.write(5, Press4);
        Press3 = EEPROM.read(3);
        EEPROM.write(4, Press3);
        Press2 = EEPROM.read(2);
        EEPROM.write(3, Press2);
        Press1 = EEPROM.read(1);
        EEPROM.write(2, Press1);
        Press0 = EEPROM.read(0);
        EEPROM.write(1, Press0);
        EEPROM.write(0, Press - 600);
        
        Temp10 = EEPROM.read(30);
        EEPROM.write(31, Temp10);
        Temp9 = EEPROM.read(29);
        EEPROM.write(30, Temp9);
        Temp8 = EEPROM.read(28);
        EEPROM.write(29, Temp8);
        Temp7 = EEPROM.read(27);
        EEPROM.write(28, Temp7);
        Temp6 = EEPROM.read(26);
        EEPROM.write(27, Temp6);
        Temp5 = EEPROM.read(25);
        EEPROM.write(26, Temp5);
        Temp4 = EEPROM.read(24);
        EEPROM.write(25, Temp4);
        Temp3 = EEPROM.read(23);
        EEPROM.write(24, Temp3);
        Temp2 = EEPROM.read(22);
        EEPROM.write(23, Temp2);
        Temp1 = EEPROM.read(21);
        EEPROM.write(22, Temp1);
        Temp0 = EEPROM.read(20);
        EEPROM.write(21, Temp0);
        EEPROM.write(20, Temp);
        
        Chass10 = EEPROM.read(50);
        EEPROM.write(51, Chass10);
        Chass9 = EEPROM.read(49);
        EEPROM.write(50, Chass9);
        Chass8 = EEPROM.read(48);
        EEPROM.write(49, Chass8);
        Chass7 = EEPROM.read(47);
        EEPROM.write(48, Chass7);
        Chass6 = EEPROM.read(46);
        EEPROM.write(47, Chass6);
        Chass5 = EEPROM.read(45);
        EEPROM.write(46, Chass5);
        Chass4 = EEPROM.read(44);
        EEPROM.write(45, Chass4);
        Chass3 = EEPROM.read(43);
        EEPROM.write(44, Chass3);
        Chass2 = EEPROM.read(42);
        EEPROM.write(43, Chass2);
        Chass1 = EEPROM.read(41);
        EEPROM.write(42, Chass1);
        Chass0 = EEPROM.read(40);
        EEPROM.write(41, Chass0);
        EEPROM.write(40, Chass);

         chas = hour ;
///////////////  ПРИЕХАЛИ  //////////
  } 
 } 
}
 
   else         //  если кнопка нажата  //
   {
   tft.fillScreen(ST7735_BLACK);
   addressP  = 0 ;
   addressT  = 20 ;
   addressCH  = 40 ;
   PressEP = EEPROM.read(addressP);  //  читаем из памяти последнее давление 
   TempEP  = EEPROM.read(addressT);  //  читаем из памяти последнюю температуру
   ChassEP = EEPROM.read(addressCH); //  читаем из памяти последний час
   tft.setCursor(5, 5);           //  устанавливаем курсор
   tft.setTextSize(2);               //  устанавливаем размер текста
   tft.setTextColor(ST7735_RED);
   if (ChassEP < 10)
   tft.println("0");
   tft.println(ChassEP);    //  выводим значения
   tft.setTextSize(1);
   tft.println("00 ");
   tft.setTextSize(2);
   tft.setTextColor(ST7735_YELLOW);
   tft.println(PressEP + 600);
   tft.println("mm ");
   tft.setTextColor(ST7735_GREEN);
   tft.println(TempEP);
   tft.println("C"); 
   addressP = addressP + 1;          //  устанавливаем следующие адреса
   addressT = addressT + 1;
   addressCH = addressCH +1;
   
   PressEP = EEPROM.read(addressP);  //  читаем из памяти последнее давление 
   TempEP  = EEPROM.read(addressT);  //  читаем из памяти последнюю температуру
   ChassEP = EEPROM.read(addressCH); //  читаем из памяти последний час
   tft.setCursor(5, 25);           //  устанавливаем курсор
   tft.setTextSize(2);               //  устанавливаем размер текста
   tft.setTextColor(ST7735_RED);
   if (ChassEP < 10)
   tft.println("0");
   tft.println(ChassEP);    //  выводим значения
   tft.setTextSize(1);
   tft.println("00 ");
   tft.setTextSize(2);   //  выводим значения
   tft.setTextColor(ST7735_YELLOW);
   tft.println(PressEP + 600);
   tft.println("mm ");
   tft.setTextColor(ST7735_GREEN);
   tft.println(TempEP);
   tft.println("C");
   addressP = addressP + 1;          //  устанавливаем следующие адреса
   addressT = addressT + 1;
   addressCH = addressCH +1;
   
   PressEP = EEPROM.read(addressP);  //  читаем из памяти последнее давление 
   TempEP  = EEPROM.read(addressT);  //  читаем из памяти последнюю температуру
   ChassEP = EEPROM.read(addressCH); //  читаем из памяти последний час
   tft.setCursor(5, 45);           //  устанавливаем курсор
   tft.setTextSize(2);               //  устанавливаем размер текста
   tft.setTextColor(ST7735_RED);
   if (ChassEP < 10)
   tft.println("0");
   tft.println(ChassEP);    //  выводим значения
   tft.setTextSize(1);
   tft.println("00 ");
   tft.setTextSize(2);   //  выводим значения   //  выводим значения
   tft.setTextColor(ST7735_YELLOW);
   tft.println(PressEP + 600);
   tft.println("mm ");
   tft.setTextColor(ST7735_GREEN);
   tft.println(TempEP);
   tft.println("C");
   addressP = addressP + 1;          //  устанавливаем следующие адреса
   addressT = addressT + 1;
   addressCH = addressCH +1;
   
   PressEP = EEPROM.read(addressP);  //  читаем из памяти последнее давление 
   TempEP  = EEPROM.read(addressT);  //  читаем из памяти последнюю температуру
   ChassEP = EEPROM.read(addressCH); //  читаем из памяти последний час
   tft.setCursor(5, 65);           //  устанавливаем курсор
   tft.setTextSize(2);               //  устанавливаем размер текста
   tft.setTextColor(ST7735_RED);
    if (ChassEP < 10)
   tft.println("0");
   tft.println(ChassEP);    //  выводим значения
   tft.setTextSize(1);
   tft.println("00 ");
   tft.setTextSize(2);    //  выводим значения
   tft.setTextColor(ST7735_YELLOW);
   tft.println(PressEP + 600);
   tft.println("mm ");
   tft.setTextColor(ST7735_GREEN);
   tft.println(TempEP);
   tft.println("C");
   addressP = addressP + 1;          //  устанавливаем следующие адреса
   addressT = addressT + 1;
   addressCH = addressCH +1;

   PressEP = EEPROM.read(addressP);  //  читаем из памяти последнее давление 
   TempEP  = EEPROM.read(addressT);  //  читаем из памяти последнюю температуру
   ChassEP = EEPROM.read(addressCH); //  читаем из памяти последний час
   tft.setCursor(5, 85);           //  устанавливаем курсор
   tft.setTextSize(2);               //  устанавливаем размер текста
   tft.setTextColor(ST7735_RED);
    if (ChassEP < 10)
   tft.println("0");
   tft.println(ChassEP);    //  выводим значения
   tft.setTextSize(1);
   tft.println("00 ");
   tft.setTextSize(2);    //  выводим значения
   tft.setTextColor(ST7735_YELLOW);
   tft.println(PressEP + 600);
   tft.println("mm ");
   tft.setTextColor(ST7735_GREEN);
   tft.println(TempEP);
   tft.println("C"); 
   addressP = addressP + 1;          //  устанавливаем следующие адреса
   addressT = addressT + 1;
   addressCH = addressCH +1;
   
   PressEP = EEPROM.read(addressP);  //  читаем из памяти последнее давление 
   TempEP  = EEPROM.read(addressT);  //  читаем из памяти последнюю температуру
   ChassEP = EEPROM.read(addressCH); //  читаем из памяти последний час
   tft.setCursor(5, 105);           //  устанавливаем курсор
   tft.setTextSize(2);               //  устанавливаем размер текста
   tft.setTextColor(ST7735_RED);
     if (ChassEP < 10)
   tft.println("0");
   tft.println(ChassEP);    //  выводим значения
   tft.setTextSize(1);
   tft.println("00 ");
   tft.setTextSize(2);    //  выводим значения
   tft.setTextColor(ST7735_YELLOW);
   tft.println(PressEP + 600);
   tft.println("mm ");
   tft.setTextColor(ST7735_GREEN);
   tft.println(TempEP);
   tft.println("C");
   addressP = addressP + 1;          //  устанавливаем следующие адреса
   addressT = addressT + 1;
   addressCH = addressCH +1;
   
   delay(5000);                      //  ждём секунду
     
   tft.fillScreen(ST7735_BLACK); //  стираем экран
   
   PressEP = EEPROM.read(addressP);  //  читаем из памяти последнее давление 
   TempEP  = EEPROM.read(addressT);  //  читаем из памяти последнюю температуру
   ChassEP = EEPROM.read(addressCH); //  читаем из памяти последний час
   tft.setCursor(5, 5);           //  устанавливаем курсор
   tft.setTextSize(2);               //  устанавливаем размер текста
   tft.setTextColor(ST7735_RED);
   if (ChassEP < 10)
   tft.println("0");
   tft.println(ChassEP);    //  выводим значения
   tft.setTextSize(1);
   tft.println("00 ");
   tft.setTextSize(2);    //  выводим значения
   tft.setTextColor(ST7735_YELLOW);
   tft.println(PressEP + 600);
   tft.println("mm ");
   tft.setTextColor(ST7735_GREEN);
   tft.println(TempEP);
   tft.println("C");
   addressP = addressP + 1;          //  устанавливаем следующие адреса
   addressT = addressT + 1;
   addressCH = addressCH +1;
   
   PressEP = EEPROM.read(addressP);  //  читаем из памяти последнее давление 
   TempEP  = EEPROM.read(addressT);  //  читаем из памяти последнюю температуру
   ChassEP = EEPROM.read(addressCH); //  читаем из памяти последний час
   tft.setCursor(5, 25);           //  устанавливаем курсор
   tft.setTextSize(2);               //  устанавливаем размер текста
   tft.setTextColor(ST7735_RED);
     if (ChassEP < 10)
   tft.println("0");
   tft.println(ChassEP);    //  выводим значения
   tft.setTextSize(1);
   tft.println("00 ");
   tft.setTextSize(2);   //  выводим значения
   tft.setTextColor(ST7735_YELLOW);
   tft.println(PressEP + 600);
   tft.println("mm ");
   tft.setTextColor(ST7735_GREEN);
   tft.println(TempEP);
   tft.println("C");
   addressP = addressP + 1;          //  устанавливаем следующие адреса
   addressT = addressT + 1;
   addressCH = addressCH +1;

   PressEP = EEPROM.read(addressP);  //  читаем из памяти последнее давление 
   TempEP  = EEPROM.read(addressT);  //  читаем из памяти последнюю температуру
   ChassEP = EEPROM.read(addressCH); //  читаем из памяти последний час
  
   tft.setCursor(5, 45);           //  устанавливаем курсор
   tft.setTextSize(2);               //  устанавливаем размер текста
   tft.setTextColor(ST7735_RED);
     if (ChassEP < 10)
   tft.println("0");
   tft.println(ChassEP);    //  выводим значения
   tft.setTextSize(1);
   tft.println("00 ");
   tft.setTextSize(2);   //  выводим значения
   tft.setTextColor(ST7735_YELLOW);
   tft.println(PressEP + 600);
   tft.println("mm ");
   tft.setTextColor(ST7735_GREEN);
   tft.println(TempEP);
   tft.println("C"); 
   addressP = addressP + 1;          //  устанавливаем следующие адреса
   addressT = addressT + 1;
   addressCH = addressCH +1;
   
   PressEP = EEPROM.read(addressP);  //  читаем из памяти последнее давление 
   TempEP  = EEPROM.read(addressT);  //  читаем из памяти последнюю температуру
   ChassEP = EEPROM.read(addressCH); //  читаем из памяти последний час
   tft.setCursor(5, 65);           //  устанавливаем курсор
   tft.setTextSize(2);               //  устанавливаем размер текста
   tft.setTextColor(ST7735_RED);
    if (ChassEP < 10)
   tft.println("0");
   tft.println(ChassEP);    //  выводим значения
   tft.setTextSize(1);
   tft.println("00 ");
   tft.setTextSize(2); //  выводим значения
   tft.setTextColor(ST7735_YELLOW);
   tft.println(PressEP + 600);
   tft.println("mm ");
   tft.setTextColor(ST7735_GREEN);
   tft.println(TempEP);
   tft.println("C");
   addressP = addressP + 1;          //  устанавливаем следующие адреса
   addressT = addressT + 1;
   addressCH = addressCH +1;
   
   PressEP = EEPROM.read(addressP);  //  читаем из памяти последнее давление 
   TempEP  = EEPROM.read(addressT);  //  читаем из памяти последнюю температуру
   ChassEP = EEPROM.read(addressCH); //  читаем из памяти последний час
   tft.setCursor(5, 85);           //  устанавливаем курсор
   tft.setTextSize(2);               //  устанавливаем размер текста
   tft.setTextColor(ST7735_RED);
    if (ChassEP < 10)
   tft.println("0");
   tft.println(ChassEP);    //  выводим значения
   tft.setTextSize(1);
   tft.println("00 ");
   tft.setTextSize(2);  //  выводим значения
   tft.setTextColor(ST7735_YELLOW);
   tft.println(PressEP + 600);
   tft.println("mm ");
   tft.setTextColor(ST7735_GREEN);
   tft.println(TempEP);
   tft.println("C");
   addressP = addressP + 1;          //  устанавливаем следующие адреса
   addressT = addressT + 1;
   addressCH = addressCH +1;
   
   PressEP = EEPROM.read(addressP);  //  читаем из памяти последнее давление 
   TempEP  = EEPROM.read(addressT);  //  читаем из памяти последнюю температуру
   ChassEP = EEPROM.read(addressCH); //  читаем из памяти последний час
   tft.setCursor(5, 105);           //  устанавливаем курсор
   tft.setTextSize(2);               //  устанавливаем размер текста
   tft.setTextColor(ST7735_RED);
     if (ChassEP < 10)
   tft.println("0");
   tft.println(ChassEP);    //  выводим значения
   tft.setTextSize(1);
   tft.println("00 ");
   tft.setTextSize(2);    //  выводим значения
   tft.setTextColor(ST7735_YELLOW);
   tft.println(PressEP + 600);
   tft.println("mm ");
   tft.setTextColor(ST7735_GREEN);
   tft.println(TempEP);
   tft.println("C");
   addressP = addressP + 1;          //  устанавливаем следующие адреса
   addressT = addressT + 1;
   addressCH = addressCH +1;
   delay(5000);                      //  ждём секунду
   
   tft.fillScreen(ST7735_BLACK); //  стираем экран
 /*    
    tft.setCursor(20, 100);
  tft.setTextColor(ST7735_YELLOW);
  tft.print(Press);
  tft.println("mm");
  prevPress  = Press ;
 
    tft.setCursor(100, 100);
  tft.setTextColor(ST7735_YELLOW);
  tft.print(Temp);
  tft.println("*C");
  minut = 0 ;
  minutX = millis() ;
  prevTemp  = Temp ;  
   
     Temp = bmp.readTemperature();      //читаем датчик
  Press = bmp.readPressure()/133.3;
  tft.fillScreen(ST7735_BLACK);
  tft.setCursor(15, 10);           //  курсор
  tft.setTextColor(ST7735_CYAN);   //  цвет
  tft.setTextSize(2);              //  размер
  tft.println(" : ");
  tft.setCursor(10, 40);           // курсор
  tft.setTextSize(3);              //  размер шрифта
  tft.setTextColor(ST7735_GREEN);  //  цвет
  tft.println(Temp);
  tft.println(" *C");
  tft.setCursor(30, 75);           //  курсор
  tft.setTextColor(ST7735_RED);  //  цвет
  tft.setTextSize(2);              //  размер
  tft.println("Давление");
  tft.setCursor(10, 100);
  tft.setTextSize(3);
  tft.setTextColor(ST7735_YELLOW);
  tft.println(Press);
  tft.println("mm");
  tft.fillScreen(ST7735_BLACK); //  стираем экран
  */
   }
 }



 



 

 Уважаемый  ValSerg.

Схема в основном из первого поста. 

Каждый пишет код для себя (под свои требования). Берите любой код , загружайте , пробуйте , меняйте под свои требования , что не получается - ищите по форуму "букварям" и мануалам , меняйте , опять пробуйте .....  

Если мне не нужна корреция по высоте (интересует абсолютное давление в точке где я нахожусь и информация о его изменнении в течении предыдущих суток (двух-трёх)(отчего голова разламывается) ) - прошу прощения ...... вникать некогда (было бы готовое решение - не жалко...  Выше что то фуромчане предлагали.).

Интервал записи высоты столбцов в память считается исходя из времени одного цикла сна (max-8сек) (дальше по вашим требованиям - кол-во циклов). 

Если Вам нужны десятые (сотые) доли миллиметра давления - имените тип переменной давления (int) на переменную с плавающей точкой (например - float )(это - "букварь" данного сайта.....)

Уважаемый Андрей1963.

Какой испльзовали дисплей (можно с фото ).

С таким контроллером нашел только 1,8 дюйма TFT SPI 128*160

Уважаемый soznik.

Я точно когда нибуть сорвусь...... 

Даже на моих хрреновых фото (телефоном сделаных) видно что ОНО и используется  ..........

Немножко модифицировал код автора, убрал контроль заряда аккумулятора, управление от кнопок, выбор диапазонов измерения, интервал - 1 сутки. Барометр стационарный, поэтому данные функции оказались не востребованы. В качестве резервного питания подключил Li-ion батарейку на 3.0v напрямую, в цепи 3.3v, на новой батарее напряжение то же самое - 3.3v, посмотрим как оно будет. Управление подсветкой дисплея, через транзистор обратной полярности, припаянный эмитером на корпус и базой через 5кОм на +5 вольт от источника питания, коллектор подключен на вход LIGHT дисплея. (Кстати, у меня почему то в отличие от дисплея автора, на вход "LIGHT" нужно подавать GND а не +3.3v). Устройство поместил в корпус KZ-51 вместе с часами из набора деталей http://www.ebay.com/itm/381432801698?_trksid=p2057872.m2749.l2649&var=650588717117&ssPageName=STRK%3AMEBIDX%3AIT
Далее планирую переделать код под базовую линию посреди экрана (на уровне 760Hg), от которой график (столбики) будут рисоваться вверх или вниз в зависимости от повышеного или пониженного давления относительно нормального. В дальнейшем, постараюсь поменять дисплей на цветной и сделать график цветным в зависимости от величины пониженного или повышенного давления.

/*********************************
Проект "Барограф"

mmHg    Pa
720    95992
740    98658
760   101325
780   103991
800   106658
                            Pmin  Pmax
РЕЖИМ ИЗМ:(740-780 ммHg = 98558 -103991 Pa)

************* Подключение дисплея Nokia 5110 к Arduino ProMini **************
// 1 - VCC---------------------------------------- +3.3v от понижающего модуля
// 2 - GND------------------------------------------------------- к общему GND
// 3 - SCE (LCD chip select (CS)-------- через R=10 kOm pin 7 Arduino ProMicro
// 4 - RST--------------------------------------------- pin 8 Arduino ProMicro
// 5 - D/C (Data/Command select)-------- через R=10 kOm pin 6 Arduino ProMicro 
// 6 - DN<MOSI> (Serial data out (DIN)-- через R=10 kOm pin 5 Arduino ProMicro
// 7 - SCLK (Serial clock out (SCLK)---- через R=10 kOm pin 4 Arduino ProMicro
// 8 - LED--------------------------------------------VCC +5v Arduino ProMicro

************** Подключение датчика BMP085 к Arduino ProMicro *****************
// 1 - VCC----- VCC +5v Arduino ProMicro
// 2 - SDA--- SDA pin 2 Arduino ProMicro
// 3 - SCL--- SCL pin 3 Arduino ProMicro
// 4 - XCLR------------- не используется
// 5 - EDC-------------- не используется 
// 6 - GND----------------- к общему GND
*****************************************************************************/

#include <Wire.h>              // библиотека шины получения и передачи данных
#include <BMP085.h>            // библиотека для работы с датчиком давления BMP085
#include <Adafruit_GFX.h>      // библиотека для работы дисплея Nokia5110
#include <Adafruit_PCD8544.h>
#include <TimeHelpers.h>       // библиотека для работы с периодами времени

//Инициализируем дисплей на указанных пинах ArduinoUNO
Adafruit_PCD8544 display = Adafruit_PCD8544(4, 5, 6, 7, 8);

BMP085 dps = BMP085();     // Модель Digital Pressure Sensor - BMP085

long Pressure = 0; // переменная для получения данных с датчика давления

long Pmax = 0; // переменная для установки максимального значения давления
long Pmin = 0; // переменная для установки минимального значения давления

int regim = 0;  // переменная - номер режима работы

int cycle = 0; // Значение переменной - шаг изменения при выполнении цикла for
int x = 70;    // Значение переменной Х - х координата дисплея
int y = 0;     // Значение переменной Y – y координата дисплея
int z = 47;    // координата z – 48-я строка дисплея(нижняя) по оси y для
               // привязки линии от значения температуры к нулевому уровню


/*-------------- Настройка времени работы циклов измерения давления --------------------------*/

#define Diagram_interval _SEC_(1234)  // переодичность вывода данных на дисплей (86400сек/70=1234 (24часа))    !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!

// объявляем переменные у0 - у70 и присваиваем им значение 47.
// При первом цикле получения данных горизонтальная линия на 47 позиции в виде 70 точек
int y0, y1, y2, y3, y4, y5, y6, y7, y8, y9, y10, y11, y12, y13, y14, y15, 
y16, y17, y18, y19, y20, y21, y22, y23, y24, y25, y26, y27, y28, y29, y30, y31,
y32, y33, y34, y35, y36, y37, y38, y39, y40, y41, y42, y43, y44, y45, y46, y47,
y48, y49, y50, y51, y52, y53, y54, y55, y56, y57, y58, y59, y60, y61, y62, y63,
y64, y65, y66, y67, y68, y69, y70=47; 

long v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, 
v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31,
v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47,
v48, v49, v50, v51, v52, v53, v54, v55, v56, v57, v58, v59, v60, v61, v62, v63,
v64, v65, v66, v67, v68, v69, v70=47; 


void setup ()
{
  Wire.begin();       // старт шины данных
  display.begin();    // старт дисплея
  delay(500);         // время на инициализацию датчика и дисплея
 
  dps.init(MODE_ULTRA_HIGHRES, 2700, true); 
  /*
  значение 2700 см = 27 метров - истинная высота Энергодара над уровнем моря,                           !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
  давление будет рассчитываться на основе этой величины. 
  Примечание: используйте функцию zeroCal после инициализации датчика.
  dps.zeroCal (101800, 0); // Установить нулевую точку
  */
    
  display.setContrast(60);  // регулировка контраста изображения
  display.clearDisplay();   // Очистка экрана и буфера дисплея
  
}


void loop() 

{
  
Diagram(); // Выполняем подпрограмму построения графика давления

// выполняем подпрограмму периодичного измерения давления Meterage()
// с переодичностью, установленной в коде для переменной Diagram_interval (сек).

DO_EVERY(Diagram_interval,

  {
   Meterage();
  }
  );
 
} // завершаем цикл void loop



//==============================================================//
//------- ПОДПРОГРАММА ПЕРИОДИЧНОСТИ ИЗМЕРЕНИЙ ДАВЛЕНИЯ --------//
//==============================================================//
void Meterage ()
{
dps.getPressure(&Pressure); // получаем данные о давлении
delay (50);

// последовательно изменяем значение давления « v » на предыдущее при каждом цикле замера
v70 = v69; v69 = v68; v68 = v67; v67 = v66; v66 = v65; v65 = v64; v64 = v63; v63 = v62; v62 = v61; v61 = v60;
v60 = v59; v59 = v58; v58 = v57; v57 = v56; v56 = v55; v55 = v54; v54 = v53; v53 = v52; v52 = v51; v51 = v50;
v50 = v49; v49 = v48; v48 = v47; v47 = v46; v46 = v45; v45 = v44; v44 = v43; v43 = v42; v42 = v41; v41 = v40;
v40 = v39; v39 = v38; v38 = v37; v37 = v36; v36 = v35; v35 = v34; v34 = v33; v33 = v32; v32 = v31; v31 = v30;
v30 = v29; v29 = v28; v28 = v27; v27 = v26; v26 = v25; v25 = v24; v24 = v23; v23 = v22; v22 = v21; v21 = v20; 
v20 = v19; v19= v18; v18 = v17; v17 = v16; v16 = v15; v15 = v14; v14 = v13; v13 = v12; v12 = v11; v11 = v10; 
v10 = v9; v9 = v8; v8 = v7; v7 = v6; v6 = v5; v5 = v4; v4 = v3; v3 = v2; v2 = v1; v1 = v0; v0 = Pressure;

} // закрываем void meterage ()


//==============================================================//
//-------- ПОДПРОГРАММА ОТОБРАЖЕНИЯ ГРАНИЦ ИЗМЕРЕНИЙ -----------//
//==============================================================//

void Draw_Bord_val ()
{
// В зависимости от выбранных пределлов границ измерений рисуем отметки значений давления
int Bord_val_min = (Pmin/133.3)-700;
int Bord_val_max= (Pmax/133.3)-700;

    display.setCursor(72,0);
    display.println (Bord_val_max);
    display.setCursor(72,10);
    display.println("<=");
    display.setCursor(72,21);
    display.println("<H");
    display.setCursor(72,32);
    display.println("<=");
    display.setCursor(72,41);
    display.println(Bord_val_min);
} // закрываем void Draw_Bord_val ()


//==============================================================//
//--------------- ПОДПРОГРАММА ПОСТРОЕНИЯ ГРАФИКА --------------//
//==============================================================//
void Diagram()
{
  dps.getPressure(&Pressure); // получаем данные о давлении
  delay (50);
  
 /********* Оформляем экран ***********/
    display.setTextSize(1);
    display.setTextColor(BLACK);
    
// устанавливаем значение мин и мах давление отображаемое на графике                             !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
switch (regim)
{
case 0:
{
  Pmin = 98658; Pmax = 103991; 
  break;
}

} // закрываем (regim)

Draw_Bord_val (); //рисуем отметки значений давления

 /*************** Рисуем значение текущего давления ********************/  
    display.setCursor(0,0);
    display.print (Pressure/133.3); // выводим текущее атм. давление переведя его в мм Рт.Ст.
    display.print ("Hg");
    
/**************** Готовим данные для вывода на график ********************/

//Значение Y (высоту линий графика 0-47) приводим пропорционально к параметрам измеряемого давления
// формируем массив из 71-го значения данных, которые будут выводиться на дисплей
int arrayDraw [71] =
{ 
y0 = map(v0, Pmin, Pmax, 47, 1),
y1 = map(v1, Pmin, Pmax, 47, 1), 
y2 = map(v2, Pmin, Pmax, 47, 1), 
y3 = map(v3, Pmin, Pmax, 47, 1),
y4 = map(v4, Pmin, Pmax, 47, 1), 
y5 = map(v5, Pmin, Pmax, 47, 1), 
y6 = map(v6, Pmin, Pmax, 47, 1), 
y7 = map(v7, Pmin, Pmax, 47, 1), 
y8 = map(v8, Pmin, Pmax, 47, 1), 
y9 = map(v9, Pmin, Pmax, 47, 1), 
y10 = map(v10, Pmin, Pmax, 47, 1), 
y11 = map(v11, Pmin, Pmax, 47, 1), 
y12 = map(v12, Pmin, Pmax, 47, 1), 
y13 = map(v13, Pmin, Pmax, 47, 1), 
y14 = map(v14, Pmin, Pmax, 47, 1), 
y15 = map(v15, Pmin, Pmax, 47, 1), 
y16 = map(v16, Pmin, Pmax, 47, 1), 
y17 = map(v17, Pmin, Pmax, 47, 1), 
y18 = map(v18, Pmin, Pmax, 47, 1), 
y19 = map(v19, Pmin, Pmax, 47, 1), 
y20 = map(v20, Pmin, Pmax, 47, 1),
y21 = map(v21, Pmin, Pmax, 47, 1), 
y22 = map(v22, Pmin, Pmax, 47, 1), 
y23 = map(v23, Pmin, Pmax, 47, 1), 
y24 = map(v24, Pmin, Pmax, 47, 1), 
y25 = map(v25, Pmin, Pmax, 47, 1), 
y26 = map(v26, Pmin, Pmax, 47, 1), 
y27 = map(v27, Pmin, Pmax, 47, 1), 
y28 = map(v28, Pmin, Pmax, 47, 1), 
y29 = map(v29, Pmin, Pmax, 47, 1), 
y30 = map(v30, Pmin, Pmax, 47, 1),
y31 = map(v31, Pmin, Pmax, 47, 1),
y32 = map(v32, Pmin, Pmax, 47, 1),
y33 = map(v33, Pmin, Pmax, 47, 1),
y34 = map(v34, Pmin, Pmax, 47, 1),
y35 = map(v35, Pmin, Pmax, 47, 1),
y36 = map(v36, Pmin, Pmax, 47, 1),
y37 = map(v37, Pmin, Pmax, 47, 1),
y38 = map(v38, Pmin, Pmax, 47, 1),
y39 = map(v39, Pmin, Pmax, 47, 1),
y40 = map(v40, Pmin, Pmax, 47, 1),
y41 = map(v41, Pmin, Pmax, 47, 1),
y42 = map(v42, Pmin, Pmax, 47, 1),
y43 = map(v43, Pmin, Pmax, 47, 1),
y44 = map(v44, Pmin, Pmax, 47, 1),
y45 = map(v45, Pmin, Pmax, 47, 1),
y46 = map(v46, Pmin, Pmax, 47, 1),
y47 = map(v47, Pmin, Pmax, 47, 1),
y48 = map(v48, Pmin, Pmax, 47, 1),
y49 = map(v49, Pmin, Pmax, 47, 1),
y50 = map(v50, Pmin, Pmax, 47, 1),
y51 = map(v51, Pmin, Pmax, 47, 1),
y52 = map(v52, Pmin, Pmax, 47, 1),
y53 = map(v53, Pmin, Pmax, 47, 1),
y54 = map(v54, Pmin, Pmax, 47, 1),
y55 = map(v55, Pmin, Pmax, 47, 1),
y56 = map(v56, Pmin, Pmax, 47, 1),
y57 = map(v57, Pmin, Pmax, 47, 1),
y58 = map(v58, Pmin, Pmax, 47, 1),
y59 = map(v59, Pmin, Pmax, 47, 1),
y60 = map(v60, Pmin, Pmax, 47, 1),
y61 = map(v61, Pmin, Pmax, 47, 1),
y62 = map(v62, Pmin, Pmax, 47, 1),
y63 = map(v63, Pmin, Pmax, 47, 1),
y64 = map(v64, Pmin, Pmax, 47, 1),
y65 = map(v65, Pmin, Pmax, 47, 1),
y66 = map(v66, Pmin, Pmax, 47, 1),
y67 = map(v67, Pmin, Pmax, 47, 1),
y68 = map(v68, Pmin, Pmax, 47, 1),
y69 = map(v69, Pmin, Pmax, 47, 1),
y70 = map(v70, Pmin, Pmax, 47, 1)};

/**************** Рисуем график ********************/
for (cycle = 0; cycle <71; cycle ++) // 71 цикл вывода 71-ой линии на дисплей
   {
    // рисуем линии на позициях от х=70 до х=0 справа налево с значениями, полученными из массива
    // с номерами согласно циклу от 0 до 71, значениями, равными от=у0 до у=70)
    display.drawLine (70-cycle, arrayDraw [cycle], 70-cycle, z, BLACK);    
    } 

display.display(); // все нарисованное выводим на экран дисплея

if (cycle >70)  // Если значение циклов cycle достигло значения больше 70 (экран дисплея заполнен)
  {
   cycle = 0;
/* номер цикла приобретает значение = 0, начинаем убирать значение с позиции по х=0
на его месте размещаем значение с поз.1, на его - с поз.2 и так далее.
Самое свежее значение выводится на позиции 70, остальные сдвигаются на 1 влево. Самое старое
значение, полученное 71 цикл назад, удаляется безвозвратно. */
  }

display.clearDisplay(); // очищаем дисплей

} // завершаем подпрограмму void Diagram()
/*********************************************************/

Уважаемый ValSerg позвольте выразить Вам респект и уважение и пожелать дальнейших успехов и удачных проектов, а также всем, у кого руки растут из головы.

Спасибо Сергей!!! И Вам НЕ СДАВАТЬСЯ!!!

Доброго времени  Андрей1963 , не ругайте пожалуйста  soznik, он очень нам погает когда Вы не отвечаете на наши вопросы , чтоб разобраться в вашем коде. Очень ждём когда Вы покажете нам Ваш код. Мы благодарны Вам за то , что дарите тепло людям. 

С уважением Алекс

Спасибо Вам, За вашу помощь в освоении проекта.

Ваш Алекс.

Уважаемый Андрей1963, если не трудно, скиньте пожалуйста ссылочки, где можно почитать о управлении Вашим дисплеем. Спасибо!

Прошу прощения.

Я пользовался темой 

http://arduino.ru/forum/proekty/mini-ostsillograf-arduino-na-lcd-5110  

43 пост - код осцилографа на этом дисплее. Остальное сейчас уже и не вспомнить..... Урывал информацию со всех форумов где упоминался 1,8" LCD.... 

Уважаемые. Я только осваиваю програмирование . Код (в 61 посте) писался методом проб. В английском я не силен.... С библиотеками пока одни проблемы.... Эта тема помогла освоить спящий режим , EEPROM, работу с массивами данных.... На этом фоне мой код под цветной дисплей выглядит ....... очень хреновым.... Переделывать пока некогда.  

Ничего, мы все тут такие)) и нечего скромничать)))

Спасибо за ссылочку, да, для изучения тут непаханные поля - и жизни не хватит), но все же стремиться нужно, будем читать..

Да "за ради бога".....  Будет времени поболе - займёмся посерьезнее.

Доброго вреиени суток.

Огромное спасибо участнику форума Андрей1963 за проект барографа пост # 38.

Предлогаю редакцию данного проекта с использованием дисплея

LCD 12864 на контролере ST7920.  Размером 3,2"

По данному дисплею пользовался статьей 

http://nnm.me/blogs/pencraft/arduino-i-graficheskiy-displey-128x64-s-kontrollerom-st7920/page2/

При подгонке графика под новый размер (100 столбцов по 40 точек)

разобрался с принципом построения графиков.

В редакции пост # 49 есть ошибка в выводе значения дясятых долей температуры.

Здесь исправил.

#include <U8glib.h>
  #include <BMP085.h> 
   #include <Wire.h>
   #include <avr/sleep.h>
   #include <avr/wdt.h>
   #include <EEPROM.h>
   #define CNT 2             //  количество циклов по 8 секунд от работы до работы
                             // Для 24 часа = 108
   int count1 = 0 ;          //  переменная для счётчика циклов по 8 сек
   volatile boolean wdt_tripped=1;


U8GLIB_ST7920_128X64 u8g(13, 12, 11, U8G_PIN_NONE);
// SCK(13)-E(6), MOSI(11)-R/W(5),CS(12)-RS(4),

 /////////// активизируем датчик давления ////////////
   BMP085 dps = BMP085();     // Модель Digital Pressure Sensor - BMP085

   float Press  = 0 ;        //  переменная  давление
   byte PressEP    ;       //  высота столбца в памяти
   byte addressP = 0;      //  адрес записи высоты столбца 
   int adresP      ;       //  адрес считывания высоты столбца 
   byte cycle = 0  ;       //  колличество столбцов в графике
   int adrP = 99 ;         //  место столбца графика
   int cons = 0 ;          //  константа высоты столбца
   const int analogInPin = A0;  // Вход вольтметра
   float sensorValue = 0;        
   float outputValue = 0;        
   long  temp = 0, Pressure = 0; // переменная для получения данных с датчика давления

   void setup()
{
   wdt_disable();          //  активация пробуждения 
   wdt_reset();            //  по сторожевому таймеру
   wdt_enable(WDTO_2S);    //  каждые 8 сек (меньше - для настройки)             
   Wire.begin();
  Wire.begin();            //  
    dps.init(MODE_ULTRA_HIGHRES, 0, true); 
   u8g.begin();        //  старт дисплея
   delay(500); 
  
   Serial.begin(9600); 
   adresP = addressP ;     //  начальный адрес чтения - текущий адрес записи
   // assign default color value

}
void loop()
{
  sensorValue = analogRead(analogInPin);            
  outputValue = float(analogRead(analogInPin))/204,6;
  // 1023 аналог / 5V =204,6
  // просыпаемся смотрим сколько циклов по 8 сек. спали
   wdt_interrupt_mode(); 
   if (wdt_tripped ==1) 
 {
   count1++;
   wdt_tripped = 0; 
   if (count1 == CNT)                   //  если уже "пора" 
   {  
  /////////////  устанавливаем константу величины столбца в зависимости от текущего давления /////////////////
  //  794(770 - 780);784(760 - 770); 774(750 - 760); 764(740 - 750); 
    dps.getPressure(&Pressure); // получаем данные о давлении
  dps.getTemperature(&temp);  //получаем данные о температуре
  Press = Pressure/133.3;

  if ( Press < 770)
  {cons = 776;}
  if ( Press < 760)
  {cons = 766;}
  if (Press < 750)
  {cons = 756;}
  if (Press < 740)
  {cons = 746;}
  //Serial.println(cons);
  //delay(100);
  
  u8g.firstPage();
do {

grafik();

} while( u8g.nextPage() );
  /////////////  пишем высоту столбца в EEPROM /////////////////////////////
   
   EEPROM.write(addressP,(cons - Press)*4);  // от константы отнимаем текущее давление , вписываем 10мм давления  в (63 - 23) величину столбца, 1мм давления-4пикселя
                                            
  grafik();                                //  рисуем график       
   addressP = addressP + 1;                 //  устанавливаем следующий адрес  
   if (addressP >= 100)                      //  адреса 0 - 100
   {addressP = 0;}
   count1 = 0;      
 }
 }
    //   и снова "баюшки"
    sleepNow();
}
                    //////  ФУНКЦИИ  //////

/////////////////  рисуем график  ////////////////////////
  void grafik()
  { 
    //display.clearDisplay();                //  очищаем дисплей
   Pressing();                            //  рисуем текущее давление и все надписи
  
    adresP = addressP ;                    //  начальный адрес чтения - текущий адрес записи
    for (cycle = 0; cycle <100; cycle ++)   //  100 циклов вывода линий на дисплей
    { 
    stolb();
    }
    //display.display();
    delay(100);
  }
//////////////  текущее давление и все надписи на дисплей //////////////
  void Pressing()
 {  
   u8g.setFont(u8g_font_timR14);
    u8g.setPrintPos(0, 13);
 u8g.print(Press,1);
  u8g.setFont(u8g_font_timR08);
 u8g.drawStr( 46, 13, "MM");

    u8g.drawStr(1,23,"<------24 HOUR------>");
    u8g.drawStr( 78, 9, "batt=");
    u8g.setPrintPos(105, 9);
    u8g.print(outputValue,1);
    u8g.drawStr(121,9,"V");   
    //u8g.drawStr( 70, 9, "temp=");
    //u8g.setPrintPos(99, 9);
    //u8g.print((float)temp/10,1);
    //u8g.drawStr(121,9,"C"); 
   ////////////  пределы отображения давления  ////////////
   u8g.setFont(u8g_font_timR10);
   if (cons == 776)
   {u8g.drawStr(100,21,"_770");}        
   if (cons == 766)
   {u8g.drawStr(100,21,"_760");}
   if (cons == 756)
   {u8g.drawStr(100,21,"_750");}
   if (cons == 746)
   {u8g.drawStr(100,21,"_740");}
   //display.setCursor(63,34);
   //display.println("-");
   
   if (cons == 776)
   {u8g.drawStr(100,61,"_760");}
   if (cons == 766)
   {u8g.drawStr(100,61,"_750");}
   if (cons == 756)
   {u8g.drawStr(100,61,"_740");}
   if (cons == 746)
   {u8g.drawStr(100,61,"_730");}
 
 
 }
 //////////////// прорисовка одного столбца  ///////
 void stolb()
 { 
   PressEP = EEPROM.read(adresP);                     //  читаем из памяти высоту столбца
  u8g.drawLine (adrP, PressEP, adrP,63);  // рисуем столбец (PressEP вместо 63 - получим одну линию)

   adrP = adrP - 1;                                   // устанавливаем место следующего столбца
   if (adrP < 0)                                      // следим за местом
   {adrP = 99 ; }                                     // при переходе через начало ставим в конец
   adresP = adresP - 1 ;                              // устанавливаем следующий адрес памяти
   if (adresP < 0)                                    //  следим за адресом
   {adresP = 99 ;}   
 }






///////////  здесь мы просто просыпаемся
   void wdt_interrupt_mode() 
   {
   wdt_reset();
   WDTCSR |= _BV(WDIE);                 // Restore WDT interrupt mode
   }
   ISR(WDT_vect) 
   {
   wdt_tripped=1;                       // set global volatile variable
   }

/////////////  а здесь засыпаем 
   void sleepNow()   
{
   _SFR_BYTE(ADCSRA) &= ~_BV(ADEN);
   set_sleep_mode(SLEEP_MODE_PWR_DOWN);   // Здесь устанавливается режим сна
   sleep_enable();                        // Включаем sleep-бит в регистре mcucr. Теперь возможен слип 
   _SFR_BYTE(ADCSRA) |= _BV(ADEN);
   sleep_mode();                          // Здесь устройство перейдет в режим сна!!!
}

В строках 7 и 35 проставить рабочии значения

В строках 123-130 выбрать что выводить на экран

температуру или напряжение 

Добрый день!!!

Может я немножко не грамотный, но не плохо было бы вместе с кодом, предоставить схемку подключения и типы используемых модулей, тогда можно будет и заказать их и повторить...

Спасибо!

  Доброго времени суток.

Смотрите пост № 1 в этой теме.

Это камень скорее всего в мой огород.

Немогу прикрепить фото.

Датчик давления подключается так-же как и в посте № 1 

Rx,Tx выводы А4, А5  Ардуины. Питание в зависимости от исполнеия модуля, у меня 5 вольтовое.

Дисплей подключается 5-ю проводами 3 данные и 2 питание.

Указанно в коментариях (строка 14 ).

Более подробно о подключении расписано в статье по указаной ссылке.

Спасибо!!!

С аванса закажу и такой дисплейчик, так что, если что, буду задавать вопросы!))

Более подробно о подключении расписано в статье по указаной ссылке.

2. Подключение дисплея к Arduino
Дисплей может быть подключен к Arduino по последовательному или параллельному порту. При работе с Arduino Uno или Nano более перспективным представляется подключение по последовательному порту – для него потребуется всего 3 выхода микроконтроллера. Итак, по порядку:

• Контакт 1 (GND) подключается к общей шине
• Контакт 2 (VCC) подключается к шине питания +5V, причем потребляемый ток сравнительно небольшой и дисплей можно питать от встроенного стабилизатора Arduino.
• Контакты 4, 5 и 6 подключаются к цифровым выходам Arduino, образуя последовательный интерфейс SPI:
контакт 4 – (RS) – соответствует линии CS (например 7)
контакт 5 – (RW) – соответствует линии MOSI (например 8)
контакт 6 – (E) – соответствует линии SCK (например 3)
номера контактов Arduino могут быть любыми, главное не забыть потом правильно указать их в тексте программы при инициализации дисплея.
• Контакт 15 (PSB) соединяется с общей шиной.
• Контакты 19 (A) и 20 (K) – это питание подсветки (+5V и GND соответственно). Для регулировки яркости подсветки можно использовать переменный резистор 10кОм, включенный между шинами питания и GND. Напряжение с его движка подается на контакт 19 дисплея.

Доброго времени суток!!!

Вы так подключали как здесь расписано? Если да, то я так понял что 3.3в питание уже не подойдет, потому, как эти дисплеи только 5-ти вольтовые. Если 5 на 5 вольт, значит резисторов между этими устройствами тоже не нужно?

Спасибо!!!

Получилось загрузить.

Всё верно кроме подсветки. Я буду делать регулируемую подсветку т.е. А- + 5V , К через полевик на корпус 

и через фоторезистор на аналоговый вход.

Пока собрано на макетной UNO на pro mini  сегодня только начал

Выводы SPI  будут подключены у портам D 4,5,6.

Да и не забывайте про регулеровку контрастности дисплея вывод 3.

На моём дисплее вывод 15 под SPI  уже на корпусе и рег. контрастности на плате.

Желаю удачи.

Прикольно! Такой огромный дисплей, тут то уже есть где "разгуляться", в смысле места хватит и под температуру и под текущее давление. Кстати, какой используется датчик температуры?, посмотрел код - DS18b20 не видно, или датчик давления имеет и датчик температуры на борту? Все, заказываю такой дисплей - все таки "размер имеет значение")). Жаль, конечно, что он не OLED тот наверное будет не дешево стоить. Я привык передние панели устройств со светодиодными матрицами изготавливать оз стекла или оргстекла и покрывать их пленкой для тонировки стекол автомобиля (сверху и на сухую), вид получается очень даже отличный, но вот для таких LCD дисплейчиков, наверное такой вариант не прокатит...

Фото передних панелей, может кому пригодится идея..

Вопрос Андрею1963.

Какими источниками вы пользовались по функции watchdog  и  sleep?

Ардуиной занимаюсь менее 3-х месяцев. 

Никак не могу разобратся в скетч с поста №38

Вставляю строчку ШИМ.

void loop()
{
  analogWrite(9, 133); // устанавливаем яркость подсветки

И начинается ерунда 26 сек. подсветка горит и 26 сек. потухшая. 

Независимо от значения

 #define CNT 2             //  количество циклов по 8 секунд от работы до работы

watchdog стоит 8 сек

  wdt_enable(WDTO_8S);    //  каждые 8 сек (меньше - для настройки)  

И где эта собака зарыта не могу понять.

Заказал сегодня вот такой дисплейчик, смотрю на него много описания и темок на форуме, по приходу займусь...

1.3" I2C IIC Serial 128X64 SH1106 OLED LCD LED Display Module for Arduino Blue

http://arduino.ru/forum/obshchii/spyashchii-rezhim

Ну и очень много выдаёт в поисковике на "спящий режим ардуино" (конкретно - сейчас уже не вспомнить).

wdt_enable(WDTO_8S)   это время одного цикла сна (2s;4s;8s максимум-8s)    #define CNT 2  - колличество циклов сна между измерениями (раз в час - 3600сек разделить на время одного цикла)

В 38посте у меня нет подсветки (делалось всё на экономию энергии).

Уважаемые коллеги вводили регулировку подсветки. В посте 61 я я сделал регулировку в зависимости от освещения фоторезистора(на фото дисплея внизу справа) чтобы не слепил ночью. 

Если каким либо способом регулировать подсветку в коде 38 поста, то только тогда когда процессор не спит (после 56 строки - раз в 8 сек ; после 60 строки - вместе с измерением ). Может и неполучится ....... Что будет на выводе регулировки во время "сна" я не знаю......

Удачи!

Большое спасибо.

Я убрал спящий режим.

Вместо wdt_enable(WDTO_8S) поставил delay (8000) /

Сейчас регулировка яркости изменяется через 8 сек. 

Можно уменьшить задержку и увеличить кол-во циклов .

А со спящим режимом как я понял рег-ка не получится.

Только я так и не смог разобратся откуда взялось этот странный цикл вкл.-выкл. 26 сек.

На led 12864 работает все нормально.

Сейчас пытаю TFT 2.2" на  ILI 9341.

Понемногу учусь.

Если не использовать спящий режим всё упрощается .......
Библиотеки <avr/sleep.h>  <avr/wdt.h> не нужны. Из кода убирается всё относящееся к спящему режиму. Регулировку подсветки сделать в основном цикле программы (void loop()) . Вместо  delay()  лучше использовать millis(). В ней задать время цикла между измерениями (тогда не будет тормозиться основная программа).

Будет время - протестим и такой вариант.

Функцию millis() еще не изучал.

Надо попробовать. Хотя в этой прграмме применение deley() мешает только скорости обновления

данных об освещении.

  #include <U8glib.h>
   #include <BMP085.h> 
   #include <Wire.h>
   #include <EEPROM.h>
   #define CNT 108         //  количество циклов по 8 секунд от работы до работы
                             // Для 24 часа = 108
   int count1 = 0 ;          //  переменная для счётчика циклов по 8 сек
  

U8GLIB_ST7920_128X64 u8g(6, 5, 4, U8G_PIN_NONE);
// SCK(6)-E(6), MOSI(5)-R/W(5),CS(4)-RS(4),

 /////////// активизируем датчик давления ////////////
   BMP085 dps = BMP085();     // Модель Digital Pressure Sensor - BMP085

   float Press  = 0 ;        //  переменная  давление
   byte PressEP    ;       //  высота столбца в памяти
   byte addressP = 0;      //  адрес записи высоты столбца 
   int adresP      ;       //  адрес считывания высоты столбца 
   byte cycle = 0  ;       //  колличество столбцов в графике
   int adrP = 99 ;         //  место столбца графика
   int cons = 0 ;          //  константа высоты столбца
   const int analogInPin = A0;  // Вход вольтметра
       
   float outputVolt = 0; 
   const int analogInPin1 = A1;  // Вход фоторезистора
     
   float outputfoto = 0;    
   long  temp = 0, Pressure = 0; // переменная для получения данных с датчика давления

   void setup()
{
  analogWrite(9, 133);
  
  Wire.begin();            //  
    dps.init(MODE_ULTRA_HIGHRES, 0, true); 
   u8g.begin();        //  старт дисплея
   delay(500); 
  
   Serial.begin(9600); 
   adresP = addressP ;     //  начальный адрес чтения - текущий адрес записи
   // assign default color value

}
void loop()
{
 int val = analogRead(analogInPin1);   
   val= constrain(val,33 ,888);      
  outputfoto = val/4;
   
    analogWrite(9, outputfoto);  //    шим контрастность LCD 9 pin     
  outputVolt = float(analogRead(analogInPin))/204,6;
  // 1023 аналог / 5V =204,6
  delay (8000);
 {
   count1++;
  
   if (count1 == CNT)                   //  если уже "пора" 
   {  
  /////////////  устанавливаем константу величины столбца в зависимости от текущего давления /////////////////
  //  794(770 - 780);784(760 - 770); 774(750 - 760); 764(740 - 750); 
    dps.getPressure(&Pressure); // получаем данные о давлении
  dps.getTemperature(&temp);  //получаем данные о температуре
  Press = Pressure/133.3;

  if ( Press < 770)
  {cons = 776;}
  if ( Press < 760)
  {cons = 766;}
  if (Press < 750)
  {cons = 756;}
  if (Press < 740)
  {cons = 746;}
  //Serial.println(cons);
  //delay(100);
  
  u8g.firstPage();
do {

grafik();

} while( u8g.nextPage() );
  /////////////  пишем высоту столбца в EEPROM /////////////////////////////
   
   EEPROM.write(addressP,(cons - Press)*4);  // от константы отнимаем текущее давление , вписываем 10мм давления  в (63 - 23) величину столбца, 1мм давления-4пикселя
                                            
  grafik();                                //  рисуем график       
   addressP = addressP + 1;                 //  устанавливаем следующий адрес  
   if (addressP >= 100)                      //  адреса 0 - 100
   {addressP = 0;}
   count1 = 0;      
 }
 }
   
}
                    //////  ФУНКЦИИ  //////

/////////////////  рисуем график  ////////////////////////
  void grafik()
  { 
    //display.clearDisplay();                //  очищаем дисплей
   Pressing();                            //  рисуем текущее давление и все надписи
  
    adresP = addressP ;                    //  начальный адрес чтения - текущий адрес записи
    for (cycle = 0; cycle <100; cycle ++)   //  100 циклов вывода линий на дисплей
    { 
    stolb();
    }
    //display.display();
    delay(100);
  }
//////////////  текущее давление и все надписи на дисплей //////////////
  void Pressing()
 {  
   u8g.setFont(u8g_font_timR14);
    u8g.setPrintPos(0, 13);
 u8g.print(Press,1);
  u8g.setFont(u8g_font_timR08);
 u8g.drawStr( 46, 13, "MM");

    u8g.drawStr(1,23,"<------24 HOUR------>");
    u8g.drawStr( 78, 9, "batt=");
    u8g.setPrintPos(105, 9);
    u8g.print(outputVolt,1);
    u8g.drawStr(121,9,"V");   
    //u8g.drawStr( 70, 9, "temp=");
    //u8g.setPrintPos(99, 9);
    //u8g.print((float)temp/10,1);
    //u8g.drawStr(121,9,"C"); 
   ////////////  пределы отображения давления  ////////////
   u8g.setFont(u8g_font_timR10);
   if (cons == 776)
   {u8g.drawStr(100,21,"_770");}        
   if (cons == 766)
   {u8g.drawStr(100,21,"_760");}
   if (cons == 756)
   {u8g.drawStr(100,21,"_750");}
   if (cons == 746)
   {u8g.drawStr(100,21,"_740");}
   //display.setCursor(63,34);
   //display.println("-");
   
   if (cons == 776)
   {u8g.drawStr(100,61,"_760");}
   if (cons == 766)
   {u8g.drawStr(100,61,"_750");}
   if (cons == 756)
   {u8g.drawStr(100,61,"_740");}
   if (cons == 746)
   {u8g.drawStr(100,61,"_730");}
 
 
 }
 //////////////// прорисовка одного столбца  ///////
 void stolb()
 { 
   PressEP = EEPROM.read(adresP);                     //  читаем из памяти высоту столбца
  u8g.drawLine (adrP, PressEP, adrP,63);  // рисуем столбец (PressEP вместо 63 - получим одну линию)

   adrP = adrP - 1;                                   // устанавливаем место следующего столбца
   if (adrP < 0)                                      // следим за местом
   {adrP = 99 ; }                                     // при переходе через начало ставим в конец
   adresP = adresP - 1 ;                              // устанавливаем следующий адрес памяти
   if (adresP < 0)                                    //  следим за адресом
   {adresP = 99 ;}   
 }

 Питание барографа сетевое , на аккамуляторе дежурное ( для него контроль напряжения ).

А с  millis() разберусь попробую вставить.

Где-то вот так функция milis() .

int count1 = 0 ;   
#define CNT 4 
unsigned long time ;
unsigned long loopTime;
//unsigned long time =0
void setup(){
  Serial.begin(9600);
  time = millis();
}
void loop(){
   
  
  time = millis();

 
  if(time >= (loopTime + 8000))
   {
   count1++; 
   loopTime = time;  
   }

  if (count1 == CNT)
   { 
     Serial.println( " pora " ) ;
     count1 = 0; 
       
    }
   
}

delay() короче . Но millis() интересней. Буду вставлять.

delay() - пауза в выполнении программы а millis() - время с момента старта программы .....

           }

Ну как то так ..... 

  #define CNT 108        //  количество циклов по 8 секунд от работы до работы
                             // Для 24 часа = 108
   int count1 = 0 ;          //  переменная для счётчика циклов по 8 сек

Значит это можно убрать.

А увеличить millis().

Конечно.....  Только не millis()  он от наших желаний не зависит (да и вообще ни от чего не зависит). А вот глянуть сколько там  millis() натикало и от него отсчитать сколько нам надо - это - запросто....

Получилось .

Сегодня уже поздно , а завтра подчистю и добавлю комментарии.

Прорисовку графика и прочей информации вывел из под функции millis().

 tim = millis();
  if(tim >= (loopTime + 864000)) //  если уже "пора" 
   {
  
   loopTime = tim;  
  
  
  

  /////////////  пишем высоту столбца в EEPROM /////////////////////////////
   
   EEPROM.write(addressP,(cons - Press)*4);  // от константы отнимаем текущее давление , вписываем 10мм давления  в (63 - 23) величину столбца, 1мм давления-4пикселя
                                            
  //grafik();                                //  рисуем график       
   addressP = addressP + 1;                 //  устанавливаем следующий адрес  
   if (addressP >= 100)                      //  адреса 0 - 100
   {addressP = 0;}
      
 }
  u8g.firstPage();
do {

grafik();

} while( u8g.nextPage() );

Сейчас все измерения на дисплей выводятся без задержки.

Да всё очень сильно упрощается.... Меня сначала озадачил интервал 14,4 мин. Потом дошло...... при помощи калькулятора.

У меня получилось пока так 

/* 96 столбцов , измерения каждые полчаса , график 48 часов , логотип "BARO" (вместо него будет или
  температура или что нибуть ещё) , фоторезистор регулировки яркости дисплея припаяю завтра ........*/
  
  
////////////////  библиотеки   ///////////////////
   #include <U8glib.h>
   #include <Adafruit_BMP085.h>
   #include <Wire.h>
   #include <EEPROM.h>
   /////////// активизируем дисплей ////////////
   U8GLIB_ST7920_128X64_4X u8g(10, 11, 12);
   /////////// активизируем датчик давления ////////////
   Adafruit_BMP085 bmp;
   ///////////////////переменные/////////////////////
   unsigned long time = 0;        //    текущее время
   unsigned long loopTime = 0;    //    время измерения
   int Press  = 0   ;      //  переменная  давление
   byte PressEP     ;      //  высота столбца в памяти
   byte addressP = 0;      //  адрес записи высоты столбца 
   int adresP = 95  ;      //  адрес считывания высоты столбца 
   byte cycle = 0   ;      //  колличество столбцов в графике
   int adrP = 95    ;      //  место столбца графика
   int cons = 0     ;      //  константа высоты столбца

void setup()
{     
   Wire.begin();
   bmp.begin();           
   //Serial.begin(9600);    //  это используется для вывода в монитор порта данных при настройке
   constanta();             //  если не выполнить эти две функции монитор будет пустой до 
   grafik();                                           //     первого измерения
}

void loop()
{
 time = millis();
 if(time >= (loopTime + 1800000))          //  если уже "пора"  то   
   {  
  /////////////  устанавливаем константу величины столбца в зависимости от текущего давления /////////////////
  //  781(760 - 770); 771(750 - 760); 761(740 - 750); 751(730 - 740)
  constanta();
 
  /////////////  пишем высоту столбца в EEPROM /////////////////////////////
   
   EEPROM.write(addressP,(cons - Press)*3);  // от константы отнимаем текущее давление , вписываем 10мм давления  в (63 - 33) величину столбца, 1мм давления-3пикселя
   grafik();                                //  рисуем график  
   addressP = addressP + 1;                 //  устанавливаем следующий адрес  
   if (addressP >= 96)                      //  адреса 0 - 95
   {addressP = 0;}
   loopTime = time; 
   delay(50);    
 }
}
                     //////  ФУНКЦИИ  //////
/////////////  устанавливаем константу величины столбца в зависимости от текущего давления /////////////////
  //  781(760 - 770); 771(750 - 760); 761(740 - 750); 751(730 - 740)
 void constanta()
 {Press = bmp.readPressure()/133.3;
  //Press = 755;
  if ( Press < 770)
  {cons = 781;}
  if ( Press < 760)
  {cons = 771;}
  if (Press < 750)
  {cons = 761;}
  if (Press < 740)
  {cons = 751;} }

/////////////////  рисуем график  ////////////////////////
void grafik()
  { Press = bmp.readPressure()/133.3;
        u8g.firstPage();                    //   открываем страницу
  do {

    u8g.setFont(u8g_font_timR24);           //  выбираем шрифт
    u8g.setPrintPos(5, 23);                 //  устанавливаем позицию
    u8g.print(Press,1);                     //  рисуем текущее давление
    //u8g.setFont(u8g_font_unifont);
    u8g.setFont(u8g_font_timR08);           //  шрифт поменьше
    u8g.print(" MM");
    u8g.drawRFrame(89,2,35,20,3);
    u8g.setPrintPos(93, 15);
    u8g.print("BARO");
    u8g.setPrintPos(2, 33);
    u8g.print("< ------ 48 chas ------ >");  
 ////////////  рисуем пределы отображения давления  ////////////
 ////////////  в зависимости от текущего давления   ////////////
    u8g.setPrintPos(1,35);
    u8g.print(".");
    u8g.setPrintPos(94,35);
    u8g.print(".");
    u8g.setPrintPos(1, 37);
    u8g.print("................................ .. ");
    
    u8g.setPrintPos(99,49);
    u8g.print("..");
  u8g.setPrintPos(109,42);
    if (cons == 781)
    {u8g.print("769");}
    if (cons == 771)
    {u8g.print("759");}
    if (cons == 761)
    {u8g.print("749");}
    if (cons == 751)
    {u8g.print("739");}
    
    u8g.setPrintPos(1,64);
    u8g.print("................................ ..  ");
    if (cons == 781)
    {u8g.print("760");}
    if (cons == 771)
    {u8g.print("750");}
    if (cons == 761)
    {u8g.print("740");}
    if (cons == 751)
    {u8g.print("730");}

    adresP = addressP ;                    //  начальный адрес чтения - текущий адрес записи
    for (cycle = 0; cycle <96; cycle ++)   //  96 циклов вывода линий на дисплей
    stolb();                               //  рисуем график отдельными столбцами (96 шт.)
    } while( u8g.nextPage() );             //  закрываем страницу
    delay(50);
  }

 void stolb()
 { 
   PressEP = EEPROM.read(adresP);    //  читаем из памяти высоту столбца
   //u8g.drawLine (adrP, PressEP, adrP,63);             // рисуем столбец (PressEP вместо 63 - получим одну линию)
   u8g.drawLine (adrP, PressEP, adrP ,PressEP); 
   adrP = adrP - 1;                                   // устанавливаем место следующего столбца
   if (adrP < 0)                                      // следим за местом
   {adrP = 95 ; }                                     // при переходе через начало ставим в конец
   adresP = adresP - 1 ;                              // устанавливаем следующий адрес памяти
   if (adresP < 0)                                    //  следим за адресом
   {adresP = 95 ;}   
 }

У меня практически тоже получилось.

Только здесь было u8g.drawPixel( adrP, PressEP);

Мне линией не понравилось дисплей мало контрастный столбиками красивей.

Можно попробовать вот так u8g.drawLine (adrP, PressEP, adrP ,PressEP+1);  по 2 пикселя.

Да ещё есть вопрос. У меня построение графика похоже  спешит.

Видимо в ардуине кварц совсем не точный. 

unsigned long time ;
unsigned long loopTime;
int n = 1 ;
void setup(){
  Serial.begin(9600);
  time = millis();
  delay (100);
}
void loop(){  
  time = millis();
  if(time >= (loopTime + 864000))
   {
   n = n+1 ;
   loopTime = time;     
  Serial.print(n ) ;  
  Serial.println("????????" ) ;       
    }
   
}

 Как на мониторе вместо "????"  вывести время компьютера.

Сейчас подумаем как проверить 

unsigned long time ;
unsigned long loopTime;
int n = 0;
void setup(){
  Serial.begin(9600);
  time = millis();
}
void loop(){  
  time = millis();
  if(time >= (loopTime + 60000))  // 1 минута для контроля 
   {
   n = n+1 ;     
  Serial.println(n ) ;    //  колл-во минут
  Serial.println(time ) ;    //  колл-во миллисекунд с момента старта программы
  loopTime = time
   }
}

Ну как то так ......  А время компа смотреть на компе ......

А я добил пока ....

/* 96 столбцов , измерения каждые полчаса , график 48 часов , логотип "BARO" (вместо него будет или
  температура или что нибуть ещё) , регулировка яркости подсветки в зависимости от освещения */
  
  
////////////////  библиотеки   ///////////////////
   #include <U8glib.h>
   #include <Adafruit_BMP085.h>
   #include <Wire.h>
   #include <EEPROM.h>
   /////////// активизируем дисплей ////////////
   U8GLIB_ST7920_128X64_4X u8g(10, 11, 12);
   /////////// активизируем датчик давления ////////////
   Adafruit_BMP085 bmp;
   ///////////////////переменные/////////////////////
   unsigned long time = 0;        //    текущее время
   unsigned long loopTime = 0;    //    время измерения
   int Press  = 0   ;      //  переменная  давление
   byte PressEP     ;      //  высота столбца в памяти
   byte addressP = 0;      //  адрес записи высоты столбца 
   int adresP = 95  ;      //  адрес считывания высоты столбца 
   byte cycle = 0   ;      //  колличество столбцов в графике
   int adrP = 95    ;      //  место столбца графика
   int cons = 0     ;      //  константа высоты столбца
   
   int analogPin = 0;      //  вход    фоторезистор на корпус
   int ledPin = 6;         //  выход подсветка

void setup()
{     
   Wire.begin();
   bmp.begin(); 
   digitalWrite(A0,HIGH);   //  включаем внутренний резистор подтяжки к "+"
   pinMode(ledPin, OUTPUT); //  6 пин - выход   
     
   //Serial.begin(9600);    //  это используется для вывода в монитор порта данных при настройке
   constanta();             //  если не выполнить эти две функции монитор будет пустой до 
   grafik();                                           //     первого измерения
}

void loop()
{
   int val = analogRead(0);         //  читаем аналоговый вход пишем в переменную  val 
  //Serial.println(val); 
   val = map(val, 25, 1024, 90, 0); //  приводим значения в обратной пропорции к выходу  ШИМа и ограничиваем выходное напряжение
                                    //  25 - min значение на 0 пине,  90 - значение ШИМа при котором достигается желаемый максимум яркости
                                                                   //  может достигать значения 255
   //Serial.println(val);
   analogWrite(6, val);             //  устанавливаем напряжение на 6 пине в соотв. с освещённостью 
                                    //  при 3,3V подсветка потребляла 14 мА    Выход держит 40мА нагрузки  
                                    //  поэтому не стал ставить ни каких транзисторов   
                                    //  BLA подключен непосредственно к  6 пину
   
 time = millis();
 if(time >= (loopTime + 1800000))          //  если уже "пора"  то   
   {  
  /////////////  устанавливаем константу величины столбца в зависимости от текущего давления /////////////////
  //  781(760 - 770); 771(750 - 760); 761(740 - 750); 751(730 - 740)
  constanta();
  /////////////  пишем высоту столбца в EEPROM /////////////////////////////
   
   EEPROM.write(addressP,(cons - Press)*3);  // от константы отнимаем текущее давление , вписываем 10мм давления  в (63 - 33) величину столбца, 1мм давления-3пикселя

   grafik();                                //  рисуем график  
   addressP = addressP + 1;                 //  устанавливаем следующий адрес  
   if (addressP >= 96)                      //  адреса 0 - 95
   {addressP = 0;}
   loopTime = time; 
   //Serial.println(loopTime);
   //delay(50);    
 }
}
                     //////  ФУНКЦИИ  //////
/////////////  устанавливаем константу величины столбца в зависимости от текущего давления /////////////////
  //  781(760 - 770); 771(750 - 760); 761(740 - 750); 751(730 - 740)
 void constanta()
 {
   Press = bmp.readPressure()/133.3;
  //Press = 755;
  if ( Press < 770)
  {cons = 781;}
  if ( Press < 760)
  {cons = 771;}
  if (Press < 750)
  {cons = 761;}
  if (Press < 740)
  {cons = 751;} 
}

/////////////////  рисуем график  ////////////////////////
void grafik()
  { Press = bmp.readPressure()/133.3;
        u8g.firstPage();                    //   открываем страницу
  do {

    u8g.setFont(u8g_font_timR24);           //  выбираем шрифт
    u8g.setPrintPos(5, 23);                 //  устанавливаем позицию
    u8g.print(Press,1);                     //  рисуем текущее давление
    //u8g.setFont(u8g_font_unifont);
    u8g.setFont(u8g_font_timR08);           //  шрифт поменьше
    u8g.print(" MM");
    u8g.drawRFrame(89,2,35,20,3);
    u8g.setPrintPos(93, 15);
    u8g.print("BARO");
    u8g.setPrintPos(2, 33);
    u8g.print("< ------ 48 chas ------ >");  
 ////////////  рисуем пределы отображения давления  ////////////
 ////////////  в зависимости от текущего давления   ////////////
    u8g.setPrintPos(1,35);
    u8g.print(".");
    u8g.setPrintPos(94,35);
    u8g.print(".");
    u8g.setPrintPos(1, 37);
    u8g.print("................................ .. ");
    
    u8g.setPrintPos(99,49);
    u8g.print("..");
  u8g.setPrintPos(109,42);
    if (cons == 781)
    {u8g.print("769");}
    if (cons == 771)
    {u8g.print("759");}
    if (cons == 761)
    {u8g.print("749");}
    if (cons == 751)
    {u8g.print("739");}
    
    u8g.setPrintPos(1,64);
    u8g.print("................................ ..  ");
    if (cons == 781)
    {u8g.print("760");}
    if (cons == 771)
    {u8g.print("750");}
    if (cons == 761)
    {u8g.print("740");}
    if (cons == 751)
    {u8g.print("730");}

    adresP = addressP ;                    //  начальный адрес чтения - текущий адрес записи
   
    for (cycle = 0; cycle <96; cycle ++)   //  96 циклов вывода линий на дисплей
    stolb();                               //  рисуем график отдельными столбцами (96 шт.)
    } while( u8g.nextPage() );             //  закрываем страницу
    //delay(10);
    
  }

 void stolb()
 { 
   PressEP = EEPROM.read(adresP);    //  читаем из памяти высоту столбца
   u8g.drawLine (adrP, PressEP, adrP ,64);            // рисуем столбец
   //u8g.drawPixel(adrP ,PressEP)                     // линия                     (спасибо  soznik) 
   //u8g.drawLine (adrP, PressEP, adrP ,PressEP+1);   // линия толщиной 2 пикселя  (спасибо soznik)
   adrP = adrP - 1;                                   // устанавливаем место следующего столбца
   if (adrP < 0)                                      // следим за местом
   {adrP = 95 ; }                                     // при переходе через начало ставим в конец
   adresP = adresP - 1 ;                              // устанавливаем следующий адрес памяти
   if (adresP < 0)                                    //  следим за адресом
   {adresP = 95 ;}   
 }

Так я пробовал устал считать решил сделать по другому.

В предидущих вариантах у Вас был добавлен сброс EEPROM.

Сброшу и посмотрю за какое время пройдет график после пересчитаю.

Надо сначала доделать батарейное питание (сегодня днём опять отключали элек-во)

Фоторезистор у меня уже подключен делителем   +5 ---- фото ---- A1 ---- R ---- КОРПУС

Переделовать не буду и полевик на подсветку стоит.

А вот транспорант BARO я увас позаимствовал.

    u8g.drawRFrame(89,0,35,15,3);
    if ( outputVolt >3.8)   
   { u8g.drawStr(93,11,"BARO"); }    
    else 
   { u8g.drawStr(93,11,"BATT"); }

Понравился он мне. Надо сейчас заставить моргать "BATT".

Почему-то не хочет работать:

Хотел заставить моргать "BATT"