Arduino.ru

Хм... А где, собственно, кнопки?

В моем коде их нет, а вот во всех остальных присутствует. В этом вся и проблема, как добавить кнопки в мои часы. Добавить не просто указать пин и что они работают как вход, а что бы они настраивали часы.

Для начала должна появиться функция опроса кнопок, которая будет возвращать "нечто". Далее, этими "нечтами" прибавляем-убавляем интересующее нас значение и переходим к следующему. Настроив все значения, записываем.
Все вместе будет называться "меню установки времени".

А что такое "бинарные часы"?

Работают-не работают?

http://nnm.me/blogs/oleg_karp/arduino-delaem-shild-binarnye-chasy-2/

собраны вот такие, только добавлены секунда и время в 24-х часовом формаите.

сижу щас опять пытаюсь добавить настройку, ни че не получается((

Что то ваши скетчи заумные слишком. Сделайте функцию на три кнопки: "+"," -", "ОК". Считайте значения минут, часов..... с RTC и последовательно их изменяйте. После изменения последнего значения, записали в RTC.

это то я понимаю, весь процесс описать могу с подробностями, а вот как реализовать...

я не программист, у нас в школе даже информатики небыло.

пока научился вслепую выставлять минуты. тыкаю на ентер, потом + или -, потом опять ентер и минуты меняются. как выставлять часы, и как  заставить мигати все это добро при установке не представляю

#include "Wire.h"   //в чем разница между этим
#include <Wire.h>   //и этим??
int latchPin = 11;
//Pin connected to SH_CP of 74HC595
int clockPin = 13;
////Pin connected to DS of 74HC595
int dataPin = 12;
//define button pins
#define enterButtPin 5
#define upButtPin 6
#define downButtPin 7

//define RTC address
//#define DS3231_I2C_ADDRESS 0x68
#define DS3231_ADDRESS 0x68

//variables for button states
int enterState = 0;
  int enterStateLast = 0;
int upState = 0;
  int upStateLast = 0;
int downState = 0;
  int downStateLast = 0;

//variables for ui
boolean blinkOn = true; //visibility of ':' between hour and minutes
boolean setVisible = false; //visibility of the set time ui

//variables for new time
int setM = 0; //users new minute value
int setH = 0; //users new hour value

//code that runs once at setup
void setup() {
  //start wire and lcd
  Wire.begin();
  //intialize buttons as inputs
  pinMode(enterButtPin, INPUT);
  pinMode(upButtPin, INPUT);
  pinMode(downButtPin, INPUT);
  pinMode(latchPin, OUTPUT);
  pinMode(clockPin, OUTPUT);
  pinMode(dataPin, OUTPUT);
 
}

//code that runs on a constant loop
void loop() {
  printDate();
  checkButtons();

}
//set the time and date to the RTC
void setRTCTime(byte second, byte minute, byte hour, byte dayOfWeek, byte
                dayOfMonth, byte month, byte year)
{
  // sets time and date data to DS3231
  Wire.beginTransmission(DS3231_ADDRESS);
  Wire.write(0); // set next input to start at the seconds register
  Wire.write(decToBcd(second)); // set seconds
  Wire.write(decToBcd(minute)); // set minutes
  Wire.write(decToBcd(hour)); // set hours
  Wire.write(decToBcd(dayOfWeek)); // set day of week (1=Sunday, 7=Saturday)
  Wire.write(decToBcd(dayOfMonth)); // set date (1 to 31)
  Wire.write(decToBcd(month)); // set month
  Wire.write(decToBcd(year)); // set year (0 to 99)
  Wire.endTransmission();
}

//read the time and date from the RTC
void readRTCTime(byte *second, byte *minute, byte *hour, byte *dayOfWeek,
                 byte *dayOfMonth, byte *month, byte *year)
{
  Wire.beginTransmission(DS3231_ADDRESS);
  Wire.write(0); // set DS3231 register pointer to 00h
  Wire.endTransmission();
  Wire.requestFrom(DS3231_ADDRESS, 7);
  // request seven bytes of data from DS3231 starting from register 00h
  *second = bcdToDec(Wire.read() & 0x7f);
  *minute = bcdToDec(Wire.read());
  *hour = bcdToDec(Wire.read() & 0x3f);
  *dayOfWeek = bcdToDec(Wire.read());
  *dayOfMonth = bcdToDec(Wire.read());
  *month = bcdToDec(Wire.read());
  *year = bcdToDec(Wire.read());
}

void checkButtons()
{
  //check enter
  enterState = digitalRead(enterButtPin);
  if (enterState != enterStateLast)
  {
    if (enterState == HIGH)
    {
      if (setVisible == true)
      {
        byte second, minute, hour, dayOfWeek, dayOfMonth, month, year;
        readRTCTime(&second, &minute, &hour, &dayOfWeek, &dayOfMonth, &month, &year);
        
        setRTCTime(0, setM, setH, dayOfWeek, dayOfMonth, month, year);
        hideSet();
      }
      else if (setVisible == false)
      {
        showSet();
      }
    }
  }
  enterStateLast = enterState;
  
  //check up
  upState = digitalRead(upButtPin);
  if (upState != upStateLast)
  {
    if (upState == HIGH)
    {
      if (setVisible == true)
      {
        addMin();
//        printSetTime();
      }
      else if (setVisible == false)
      {
        showSet();
      }
    }
  }
  upStateLast = upState;

  //check down
  downState = digitalRead(downButtPin);
  if (downState != downStateLast)
  {
    if (downState == HIGH)
    {
      if (setVisible == true)
      {
        subMin();

      }
      else if (setVisible == false)
      {
        showSet();
      }
    }
  }
  downStateLast = downState;
}

//displays the new time interface in the bottom of the LCD
void showSet ()
{
  //update new time variables to current RTC values
  byte second, minute, hour, dayOfWeek, dayOfMonth, month, year;
  readRTCTime(&second, &minute, &hour, &dayOfWeek, &dayOfMonth, &month, &year);
    setH = hour, DEC;
    setM = minute, DEC;
  setVisible = true;
}

//hides the new time interface
void hideSet ()
{
  setVisible = false;
}

//adds a minute to new time
void addMin()
{
  if (setM < 59)
  {
    setM++;
  }
  else if (setM == 59)
  {
    setM = 0;
    addHr();
  }
}

//subtracts a minute from new time
void subMin()
{
  if (setM > 0)
  {
    setM--;
  }
  else if (setM == 0)
  {
    setM = 59;
    subHr();
  }
}

//adds an hour to new time
void addHr ()
{
  if (setH < 23)
  {
    setH++;
  }
  else if (setH == 23)
  {
    setH = 0;
  }
}

//subtracts an hour from new time
void subHr ()
{
  if (setH > 0)
  {
    setH--;
  }
  else if (setH == 0)
  {
    setH = 23;
  }
}

void setDateTime(){
byte second = 0; //0-59
byte minute = 05; //0-59
byte hour = 18; //0-23
byte dow = 2; //1-7
byte day = 8; //1-31
byte month = 11; //1-12
byte year = 11; //0-99
byte getTemp = 0;
Wire.beginTransmission(DS3231_ADDRESS);
Wire.write(0); //stop Oscillator
Wire.write(decToBcd(second));
Wire.write(decToBcd(minute));
Wire.write(decToBcd(hour));
Wire.write(decToBcd(day)); //число
Wire.write(decToBcd(dow)); //день недели
Wire.write(decToBcd(month));
Wire.write(decToBcd(year));
Wire.write(decToBcd(getTemp));
Wire.write(0); //start 
Wire.endTransmission();
}
byte decToBcd(byte val){
// Convert normal decimal numbers to binary coded decimal
return ( (val/10*16) + (val%10) );
}
byte bcdToDec(byte val) {
// Convert binary coded decimal to normal decimal numbers
return ( (val/16*10) + (val%16) );
}
void printDate(){
// Reset the register pointer
Wire.beginTransmission(DS3231_ADDRESS);
Wire.write(0);
Wire.endTransmission();
Wire.requestFrom(DS3231_ADDRESS, 7);
int second = bcdToDec(Wire.read());
int minute = bcdToDec(Wire.read());
int hour = bcdToDec(Wire.read() & 0b111111); //24 hour time
int dow = bcdToDec(Wire.read()); //0-6 -> sunday — Saturday
int day = bcdToDec(Wire.read());
int month = bcdToDec(Wire.read());
int year = bcdToDec(Wire.read());
int getTemp = bcdToDec(Wire.read());
/////////////////////////////////////////////////////////////////


//////////////////////////////////////////////////////////////////


//if (hour>12) hour=hour-12;
digitalWrite(latchPin, 0);
//count up on GREEN LEDs
shiftOut(dataPin, clockPin,MSBFIRST, second);
shiftOut(dataPin, clockPin,MSBFIRST, minute); 
//count down on RED LEDs
shiftOut(dataPin, clockPin,MSBFIRST, hour);
//return the latch pin high to signal chip that it 
//no longer needs to listen for information
digitalWrite(latchPin, 1);
}

понятно дело что это ужасно выглядит, что то по моему делается даже два раза)) но по другому пока не смог...

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

#include <DS3231.h>
#include <Wire.h> 

//define button pins
#define enterButtPin 5
#define upButtPin 6
#define downButtPin 7

//define RTC address
#define DS3231_ADDRESS 0x68

//variables for button states
int enterState = 0;
  int enterStateLast = 0;
int upState = 0;
  int upStateLast = 0;
int downState = 0;
  int downStateLast = 0;

//variables for ui
boolean blinkOn = true; //visibility of ':' between hour and minutes
boolean setVisible = false; //visibility of the set time ui

//variables for new time
int setM = 0; //users new minute value
int setH = 0; //users new hour value

//code that runs once at setup
void setup() {
  //start wire and lcd
  Wire.begin();
  //intialize buttons as inputs
  DDRB |= 1 << 3; // pinMode(11, OUTPUT);
  DDRB |= 1 << 4; // pinMode(12, OUTPUT);
  DDRB |= 1 << 5; // pinMode(13, OUTPUT);
  DDRD &= ~(1<<3); // pinMode(5, INPUT);
  DDRD &= ~(1<<4); // pinMode(6, INPUT);
  DDRD &= ~(1<<5); // pinMode(7, INPUT);

}

//code that runs on a constant loop
void loop() {
  printDate();
  checkButtons();

}
//set the time and date to the RTC
void setRTCTime(byte second, byte minute, byte hour, byte dayOfWeek, byte
                dayOfMonth, byte month, byte year)
{
  // sets time and date data to DS3231
  Wire.beginTransmission(DS3231_ADDRESS);
  Wire.write(0); // set next input to start at the seconds register
  Wire.write(decToBcd(second)); // set seconds
  Wire.write(decToBcd(minute)); // set minutes
  Wire.write(decToBcd(hour)); // set hours
  Wire.endTransmission();
}

//read the time and date from the RTC
void readRTCTime(byte *second, byte *minute, byte *hour, byte *dayOfWeek,
                 byte *dayOfMonth, byte *month, byte *year)
{
  Wire.beginTransmission(DS3231_ADDRESS);
  Wire.write(0); // set DS3231 register pointer to 00h
  Wire.endTransmission();
  Wire.requestFrom(DS3231_ADDRESS, 7);
  // request seven bytes of data from DS3231 starting from register 00h
  *second = bcdToDec(Wire.read() & 0x7f);
  *minute = bcdToDec(Wire.read());
  *hour = bcdToDec(Wire.read() & 0x3f);
}

void checkButtons()
{
  //check enter
  enterState = digitalRead(enterButtPin);
  if (enterState != enterStateLast)
  {
    if (enterState == HIGH)
    {
      if (setVisible == true)
      {
        byte second, minute, hour, dayOfWeek, dayOfMonth, month, year;
        readRTCTime(&second, &minute, &hour, &dayOfWeek, &dayOfMonth, &month, &year);
        
        setRTCTime(0, setM, setH, dayOfWeek, dayOfMonth, month, year);
        hideSet();
      }
      else if (setVisible == false)
      {
        showSet();
      }
    }
  }
  enterStateLast = enterState;
  
  //check up
  upState = digitalRead(upButtPin);
  if (upState != upStateLast)
  {
    if (upState == HIGH)
    {
      if (setVisible == true)
      {
        addMin();
//        printSetTime();
      }
      else if (setVisible == false)
      {
        showSet();
      }
    }
  }
  upStateLast = upState;

  //check down
  downState = digitalRead(downButtPin);
  if (downState != downStateLast)
  {
    if (downState == HIGH)
    {
      if (setVisible == true)
      {
        subMin();

      }
      else if (setVisible == false)
      {
        showSet();
      }
    }
  }
  downStateLast = downState;
}

//displays the new time interface in the bottom of the LCD
void showSet ()
{
  //update new time variables to current RTC values
  byte second, minute, hour, dayOfWeek, dayOfMonth, month, year;
  readRTCTime(&second, &minute, &hour, &dayOfWeek, &dayOfMonth, &month, &year);
    setH = hour, DEC;
    setM = minute, DEC;
  setVisible = true;
}

//hides the new time interface
void hideSet ()
{
  setVisible = false;
}

//adds a minute to new time
void addMin()
{
  if (setM < 59)
  {
    setM++;
  }
  else if (setM == 59)
  {
    setM = 0;
    addHr();
  }
}

//subtracts a minute from new time
void subMin()
{
  if (setM > 0)
  {
    setM--;
  }
  else if (setM == 0)
  {
    setM = 59;
    subHr();
  }
}

//adds an hour to new time
void addHr ()
{
  if (setH < 23)
  {
    setH++;
  }
  else if (setH == 23)
  {
    setH = 0;
  }
}

//subtracts an hour from new time
void subHr ()
{
  if (setH > 0)
  {
    setH--;
  }
  else if (setH == 0)
  {
    setH = 23;
  }
}
void setDateTime(){
byte second = 0; //0-59
byte minute = 05; //0-59
byte hour = 18; //0-23
byte dow = 2; //1-7
byte day = 8; //1-31
byte month = 11; //1-12
byte year = 11; //0-99
byte getTemp = 0;
}
byte decToBcd(byte val){
// Convert normal decimal numbers to binary coded decimal
return ( (val/10*16) + (val%10) );
}
byte bcdToDec(byte val) {
// Convert binary coded decimal to normal decimal numbers
return ( (val/16*10) + (val%16) );
}
void printDate(){
// Reset the register pointer
Wire.beginTransmission(DS3231_ADDRESS);
Wire.write(0);
Wire.endTransmission();
Wire.requestFrom(DS3231_ADDRESS, 7);
int second = bcdToDec(Wire.read());
int minute = bcdToDec(Wire.read());
int hour = bcdToDec(Wire.read() & 0b111111); //24 hour time

/////////////////////////////////////////////////////////////////


//////////////////////////////////////////////////////////////////

PORTB &= ~(1 << 3); //digitalWrite(latchPin, 0);
shiftOut(12, 13,MSBFIRST, second);
shiftOut(12, 13,MSBFIRST, minute); 
shiftOut(12, 13,MSBFIRST, hour);
PORTB |= 1 << 3; //digitalWrite(latchPin, 1);
}

Назревает что то такое. попробую дополнить еще

#define Set 5            //кнопка Set
#define Up 6             //кнопка Up
#define Down 7           //кнопка Down
int H = 0;               //переменная хранения часов
int M = 0;               //переменная хранения минут
int flagH = 0;           //режим отображения настройки часов
int flagM = 0;           //режим отображения настройки минут

void setup() {
pinMode(Set, INPUT);    //кнопка Set как вход
pinMode(Up, INPUT);     //кнопка Up как вход
pinMode(Down, INPUT);   //кнопка Down как вход
}

void loop() {
 if (digitalRead(Set)==HIGH) //если кнопка Set нажата
 {
 flagH = 1;                   //включаем режим настройки часов
 //читаем часы из DS3231
 //присваиваем переменной H значение часов
 //мигаем переменной H
 if (digitalRead(Up)==HIGH){//если нажать Up то H ++
   H = H++;}
 if (digitalRead(Down)==HIGH){//если нажать Down то H --
   H = H--;}
 if (H > 23){//если H больше 23 то это 0
   H = 0;}
 if (H < 0){//если H меньше 0 то это 23
   H = 23;}
 //если нажать Set, записываем переменную H как часы в DS3231
 flagH = 0, flagM = 1;        //переключаем режим настройки с часов на минуты
 //читаем минуты из DS3231
 //присваиваем переменной M значение минут
 //мигаем переменной M
 if (digitalRead(Up)==HIGH){//если нажать Up то M ++
   M = M++;}
 if (digitalRead(Down)==HIGH){//если нажать Down то M --
   M = M--;}
 if (M > 59){//если M больше 59 то это 0
   M = 0;}
 if (M < 0){//если M меньше 0 то это 59
   M = 59;}
 //если нажать Set, записываем переменную M как минуты в DS3231
 flagM = 0;         //выключаем
 }
  else{ //иначе
 //отображаем время
 }
}

Посмотрите здесь 282 пост. Код большой и лобовой, но практически все в функциях и уже второй год работает. Можете и сначала почитать, это не руководство к действию, а последовательный полет фантазии.))))

Спасибо, обязательно гляну. Просто еще большой проблемой является помигать устанавливаемым значением на этих часах.

Я конечно почитаю еще про 74hc595, но без Вас точно не осилю.

"последовательный полет фантазии."
Здесь похоже ни у кого подобного девайса нет, как и желания его создавать. Рубим все на мелкие самодостаточные кусочки-функции, а потом складываем их вместе. Есть функция обработки кнопок, есть мигания чем либо, есть считывания из RTC в переменные + обработка кнопок получим инструмент изменения этих переменных и т.д.
Начнете пытаться все пихать в loop, увязнете по самые уши.

Неистово плюсую.

boolean time;

boolean time;

отображает время в двоичном коде. в виде едениц и нулей, которые представлены в виде горящих (1), и не горящих (0) светодиодов

это вроде все что нужно с того кода, но все равно ничего не выходит...(((

#include <EEPROM.h>
#include <Wire.h>                   //Подключаем библиотеку для использования однопроводного интерфейса                                     

#include <IRremote.h>               //Подключаем библиотеку для IR сенсора

//=====IR_Sensor*
#define recvPin 3                   //Вход IR-приемника и кнопки пульта
uint32_t val; 
IRrecv irrecv(recvPin);
decode_results results;



//=====Rtc_Clock*
#define DS3231_I2C_ADDRESS 104 
byte seconds, minutes, hours, day, date, month, year;
byte decToBcd (byte val){return((val/10*16)+(val%10));}

void setup() {
  Wire.begin();
  Serial.begin(9600);
  irrecv.enableIRIn();                                //Включаем IR-сенсор
 

}

//========== Обработка IR-сенсора, определение кнопок
byte keyIr(){
  if (irrecv.decode(&results)){       //Если пришел пакет и этот пакет не FF сохраняем правильный пакет в переменную
//  if (results.value!=0xFFFFFFFF){   //Если пришел FF, соответственно пропускаем.
    val=results.value; //}            //Сверяем значение из переменной val.. если пришла команда повтора (пакет с FF)    
    irrecv.resume();}                 //В переменной останется прошлый, правильный, пакет и код выполнится повторно.
//  Serial.println(val,HEX);          //Далее, очистить входящий буфер
//  Serial.println(" ");
  if (val==0x41BEC03F) return 1;      //setup      KEY1
  if (val==0x41BE40BF) return 2;      //left       KEY2
  if (val==0x41BED02F) return 3;      //up         KEY3
  if (val==0x41BE609F) return 4;      //down       KEY4 
  if (val==0x41BEB04F) return 5;      //right      KEY5
  if (val==0x41BEF00F) return 6;      //exit       POWER_KEY
  if (val==0x41BE708F) return 7;      //vol_down   KEY9
  if (val==0x41BE10EF) return 8;      //vol_up     KEY8
  if (val==0x41BE20DF) return 9;      //slide      KEY9
  if (val==0x41BEA05F) return 10;     //stop       KEY10
    else return 0;                    //ежели ничего ненажмато
}

//========== Обработка IR-кнопок
void keyI(){
  byte KEY=keyIr();            

//========== Обработка Входа в Меню
      if (KEY==1){                            //ВХОД В МЕНЮ и проверка блокировки от возврата. Принимаем код клавиши
    val=0;

    

//=========== Обработка Меню, параметры установки времени
//void setClock(){ // установка часов
  byte pos=0;
    
    while(keyIr()!=1){                                   //Крутим цикл пока не будет Setup
    byte KEY=keyIr();                                    //Читаем состояние кнопок
    val=0;
//      delay(200);                                      //Если убрать, не работает подсветка уст.позиции
       

   
    
    if (KEY==2 && pos==3){                                //Выход из подменю без сохранения       
                                            //Очищаем на всякий случай дисплейчик
    return;}    
    

      if (pos<3) pos=3;                                     //Устанавливаем курсор согласно позиции
    if (KEY==5 && pos<21) pos += 3;                         //Крутим позицию право-лево
    else if (KEY==2 && pos>3) pos -= 3;
    
    else if (pos==3 && KEY==3) hours++;                     //Крутим значения
    else if (pos==3 && KEY==4) hours--;
    else if (pos==6 && KEY==3) minutes++;
    else if (pos==6 && KEY==4) minutes--;
    else if (pos==9 && KEY==3) seconds++;
    else if (pos==9 && KEY==4) seconds--;
    else if (pos==12 && KEY==3) day++;
    else if (pos==12 && KEY==4) day--;     
    else if (pos==15 && KEY==3) date++;
    else if (pos==15 && KEY==4) date--;    
    else if (pos==18 && KEY==3) month++;
    else if (pos==18 && KEY==4) month--;    
    else if (pos==21 && KEY==3) year++;
    else if (pos==21 && KEY==4) year--;  
    
    if (hours>23) hours=0;
    else if (minutes>59) minutes=0;
    else if (seconds>59) seconds=0;
    else if (day>7) day=1;
    else if (date>31) date=1;
    else if (month>12) month=1;
    else if (year>99) year=0;
  

  setRtc(seconds, minutes, hours, day, date, month, year); 
   
}




//=========== Обработка установки RTC часов
void setRtc(byte seconds, byte minutes, byte hours, byte day, byte date, byte month, byte year){
  Wire.beginTransmission(DS3231_I2C_ADDRESS);        //104 is DS3231 device address
  Wire.write(0x00);                                  //Start at register 0
  Wire.write(decToBcd(seconds));
  Wire.write(decToBcd(minutes));
  Wire.write(decToBcd(hours));
  Wire.write(decToBcd(day));
  Wire.write(decToBcd(date));
  Wire.write(decToBcd(month));
  Wire.write(decToBcd(year));
  Wire.endTransmission();
}

//=========== Обработка RTC часов
void timeRtc(){
  Wire.beginTransmission(DS3231_I2C_ADDRESS);        //104 is DS3231 device address
  Wire.write(0x00);                                  //Start at register 0
  Wire.endTransmission();
  Wire.requestFrom(DS3231_I2C_ADDRESS, 7);           //Request seven bytes
      if(Wire.available()){ 
    seconds = Wire.read();                           //Get second
    minutes = Wire.read();                           //Get minute
    hours   = Wire.read();                           //Get hour
    day     = Wire.read();
    date    = Wire.read();
    month   = Wire.read();                           //Get month
    year    = Wire.read();
       
    seconds = (((seconds & B11110000)>>4)*10 + (seconds & B00001111));   //Convert BCD to decimal
    minutes = (((minutes & B11110000)>>4)*10 + (minutes & B00001111));
    hours   = (((hours & B00110000)>>4)*10 + (hours & B00001111));       //Convert BCD to decimal (assume 24 hour mode)
    day     = (day & B00000111); // 1-7
    date    = (((date & B00110000)>>4)*10 + (date & B00001111));         //Convert BCD to decimal  1-31
    month   = (((month & B00010000)>>4)*10 + (month & B00001111));       //msb7 is century overflow
    year    = (((year & B11110000)>>4)*10 + (year & B00001111));
  }
}

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

  if (digitalRead(5)==HIGH){
   
  hour++;
   setDateTime();
}
if (digitalRead(6)==HIGH){
  setDateTime();
  hour--;
  
}

функция timeRtc считывает значения из часов. seRtc записывает.
Как сделано у вас, корректно работать не будет. Цикл работает очень быстро, ++ или -- за нажатие успевают сработать бешеное количество раз. Нужны или защелка или замедлитель.
По кнопкам посмотрите титановый велосипед Клапауция.

меняю титановый велосипед на замедлитель... два замедлителя ящик замедлителей

хнык хнык... ну я и наговнокодил((( помогите что делать дальше???

#include "Wire.h"
#include <DS3231.h>
#define DS3231_ADDRESS 0x68
int latchPin = 11;
//Pin connected to SH_CP of 74HC595
int clockPin = 13;
////Pin connected to DS of 74HC595
int dataPin = 12;
#define Set 5 //кнопка меню
#define Up 6 //кнопка +
#define Down 7 //кнопка -
int H = 0; //переменная хранения часов
int M = 0; //переменная хранения минут
int regim=1; //режимы настройки часов
int flag=0; //флаг для кнопки Сет
int flagUp=0; //флаг для кнопки Уп
int flagDown=0; //флаг для кнопки Довн
void setup(){
  Serial.begin(9600);
Wire.begin();
// setDateTime(); // Первый раз запустит для установки текущего времени, второй раз запускаем "закоментированно"
pinMode(latchPin, OUTPUT);
pinMode(clockPin, OUTPUT);
pinMode(dataPin, OUTPUT);
pinMode(Set, INPUT); //кнопка как вход
pinMode(Up, INPUT); //кнопка как вход
pinMode(Down, INPUT); //кнопка как вход
}
void loop(){
printDate();
//delay(1000);
}
void setDateTime(){
byte second = 0; //0-59
byte minute = 05; //0-59
byte hour = 18; //0-23
byte dow = 2; //1-7
byte day = 8; //1-31
byte month = 11; //1-12
byte year = 11; //0-99
byte getTemp = 0;
Wire.beginTransmission(DS3231_ADDRESS);
Wire.write(0); //stop Oscillator
Wire.write(decToBcd(second));
Wire.write(decToBcd(minute));
Wire.write(decToBcd(hour));
Wire.write(decToBcd(day)); //число
Wire.write(decToBcd(dow)); //день недели
Wire.write(decToBcd(month));
Wire.write(decToBcd(year));
Wire.write(decToBcd(getTemp));
Wire.write(0); //start 
Wire.endTransmission();
}
byte decToBcd(byte val){
// Convert normal decimal numbers to binary coded decimal
return ( (val/10*16) + (val%10) );
}
byte bcdToDec(byte val) {
// Convert binary coded decimal to normal decimal numbers
return ( (val/16*10) + (val%16) );
}
void printDate(){
// Reset the register pointer
Wire.beginTransmission(DS3231_ADDRESS);
Wire.write(0);
Wire.endTransmission();
Wire.requestFrom(DS3231_ADDRESS, 7);
int second = bcdToDec(Wire.read());
int minute = bcdToDec(Wire.read());
int hour = bcdToDec(Wire.read() & 0b111111); //24 hour time
int dow = bcdToDec(Wire.read()); //0-6 -> sunday — Saturday
int day = bcdToDec(Wire.read());
int month = bcdToDec(Wire.read());
int year = bcdToDec(Wire.read());
int getTemp = bcdToDec(Wire.read());

////////////////////////////////////////////////////////////////
/////////////////////////Установка и отображение времени//////////////////////
////////////////////////////////////////////////////////////////
if(digitalRead(Set)==HIGH&&flag==0)

  regim++;
  flag=1;
  if(regim > 3)
  {
    regim=1;
  }
  if(digitalRead(Set)==LOW&&flag==1)
  {
    flag=0;
  }
///////////////////////////////////

 //////////////////////////////////////
 if(regim==1)
 {
  //regim pokaza vremeni
   Serial.println("Regim-1");
digitalWrite(latchPin, 0);
shiftOut(dataPin, clockPin,MSBFIRST, second);
shiftOut(dataPin, clockPin,MSBFIRST, minute); 
shiftOut(dataPin, clockPin,MSBFIRST, hour);
digitalWrite(latchPin, 1);
   }
 ////////////////////////////////////////

////////////////////////////////////
 if(regim==2)
 {
  //regim ustanovki chasov
  Serial.println("Regim-2");
   H = hour;
   digitalWrite(latchPin, 0);
   shiftOut(dataPin, clockPin,MSBFIRST, second);
   shiftOut(dataPin, clockPin,MSBFIRST, minute); 
   shiftOut(dataPin, clockPin,MSBFIRST, H);
   digitalWrite(latchPin, 1);
   delay(400); //необходимо избавится
   digitalWrite(latchPin, 0);
   shiftOut(dataPin, clockPin,MSBFIRST, second);
   shiftOut(dataPin, clockPin,MSBFIRST, minute); 
   shiftOut(dataPin, clockPin,MSBFIRST, 0);
   digitalWrite(latchPin, 1);
   delay(400); //необходимо избавится
  if(digitalRead(Up)==HIGH&&flagUp==0)
  {
    Serial.println("H++");
   // H++; // как правильно?? так?
    H = H++; //или так?
    flag=1;
  }
    if(digitalRead(Up)==LOW&&flagUp==1)
  {
    flag=0;
  }
  if(digitalRead(Down)==HIGH&&flagDown==0)
  {
    Serial.println("H--");
    //H--; // как правильно?? так?
    H = H--; //или так?
    flagDown=1;
  }
    if(digitalRead(Down)==LOW&&flagDown==1)
  {
    flagDown=0;
  }
if(H > 23)
  {
    H = 0;
  }
if(H < 0);
  {
    H = 23;
  }
 }
 ////////////////////////////////////

 ////////////////////////////////////
 
 if(regim==3)
 {
  //regim ustanovki minut
  Serial.println("Regim-3");
   M = minute;
   digitalWrite(latchPin, 0);
   shiftOut(dataPin, clockPin,MSBFIRST, second);
   shiftOut(dataPin, clockPin,MSBFIRST, M); 
   shiftOut(dataPin, clockPin,MSBFIRST, hour);
   digitalWrite(latchPin, 1);
   delay(400); //необходимо избавится
   digitalWrite(latchPin, 0);
   shiftOut(dataPin, clockPin,MSBFIRST, second);
   shiftOut(dataPin, clockPin,MSBFIRST, 0); 
   shiftOut(dataPin, clockPin,MSBFIRST, hour);
   digitalWrite(latchPin, 1);
   delay(400); //необходимо избавится

  if(digitalRead(Up)==HIGH&&flagUp==0)
  {
    Serial.println("M++");
    M = M++;
    flagUp=1;
  }
    if(digitalRead(Up)==LOW&&flagUp==1)
  {
    flagUp=0;
  }
  if(digitalRead(Down)==HIGH&&flagDown==0)
  {
    Serial.println("M--");
    M = M--;
    flagDown=1;
  }
    if(digitalRead(Down)==LOW&&flagDown==1)
  {
    flagDown=0;
  }
if(H > 59)
  {
    M = 0;
  }
if(M < 0);
  {
    M = 59;
  }
 }
}
 //////////////////////////////////////

 //////////////////////////////////////

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

и еще я не понял где происходит сброс минут в 0 при входе в режим 1

Обана, ты ведь на рекорд шел. Никак забанили?

А откуда узнали, что ничего не прибавляется?
Запись в часы, строки 34-54, по образу и подобию.

И ведь говорил, не пихайте все в loop. То, что вы это сделали в функции, которая вызывается при каждом проходе, ничего не изменилось. В итоге гора ифов, которая непонятно как работает.

Какой рекорд? За что забанить?

а со строчками 34-54 я пробовал, что то не получилось((

А откуда узнали, что ничего не прибавляется?

по нажатию кнопок светодиоды какие горели, такие и горят

>> И ведь говорил, не пихайте все в loop

я вообще не программист не разу, не знаю как по другому сделать

да - ихтамнеты утверждают, что их детям не поотрывает ноги российскими фугасами потому, что "ихтамнет!".. наивные.

Вообще ни чего не понял хД

забей - кому нужно, тот понял.

не понял что поменял, но минуты теперь не сбрасываются

и как правильно? Н++ или Н=Н++

#include "Wire.h"
#include <DS3231.h>
#define DS3231_ADDRESS 0x68
int latchPin = 11;
//Pin connected to SH_CP of 74HC595
int clockPin = 13;
////Pin connected to DS of 74HC595
int dataPin = 12;
#define Set 5 //кнопка меню
#define Up 6 //кнопка +
#define Down 7 //кнопка -
int H = 0; //переменная хранения часов
int M = 0; //переменная хранения минут
int regim=1; //режимы настройки часов
int flag=0; //флаг для кнопки Сет
int flagUp=0; //флаг для кнопки Уп
int flagDown=0; //флаг для кнопки Довн
void setup(){
  Serial.begin(9600);
Wire.begin();
// setDateTime(); // Первый раз запустит для установки текущего времени, второй раз запускаем "закоментированно"
pinMode(latchPin, OUTPUT);
pinMode(clockPin, OUTPUT);
pinMode(dataPin, OUTPUT);
pinMode(Set, INPUT); //кнопка как вход
pinMode(Up, INPUT); //кнопка как вход
pinMode(Down, INPUT); //кнопка как вход
}
void loop(){
printDate();
//delay(1000);
}

void setDateTime(){
byte second = 0; //0-59
byte minute = 05; //0-59
byte hour = 18; //0-23
byte dow = 2; //1-7
byte day = 8; //1-31
byte month = 11; //1-12
byte year = 11; //0-99
byte getTemp = 0;
Wire.beginTransmission(DS3231_ADDRESS);
Wire.write(0); //stop Oscillator
Wire.write(decToBcd(second));
Wire.write(decToBcd(minute));
Wire.write(decToBcd(hour));
Wire.write(decToBcd(day)); //число
Wire.write(decToBcd(dow)); //день недели
Wire.write(decToBcd(month));
Wire.write(decToBcd(year));
Wire.write(decToBcd(getTemp));
Wire.write(0); //start 
Wire.endTransmission();
}
byte decToBcd(byte val){
// Convert normal decimal numbers to binary coded decimal
return ( (val/10*16) + (val%10) );
}
byte bcdToDec(byte val) {
// Convert binary coded decimal to normal decimal numbers
return ( (val/16*10) + (val%16) );
}
void printDate(){
// Reset the register pointer
Wire.beginTransmission(DS3231_ADDRESS);
Wire.write(0);
Wire.endTransmission();
Wire.requestFrom(DS3231_ADDRESS, 7);
int second = bcdToDec(Wire.read());
int minute = bcdToDec(Wire.read());
int hour = bcdToDec(Wire.read() & 0b111111); //24 hour time
int dow = bcdToDec(Wire.read()); //0-6 -> sunday — Saturday
int day = bcdToDec(Wire.read());
int month = bcdToDec(Wire.read());
int year = bcdToDec(Wire.read());
int getTemp = bcdToDec(Wire.read());

////////////////////////////////////////////////////////////////
/////////////////////////Установка и отображение времени//////////////////////
////////////////////////////////////////////////////////////////
if(digitalRead(Set)==HIGH&&flag==0)

  regim++;
  flag=1;
  if(regim > 3)
  {
    regim=1;
  }
  if(digitalRead(Set)==LOW&&flag==1)
  {
    flag=0;
  }
///////////////////////////////////

 //////////////////////////////////////
 if(regim==1)
 {
  //regim pokaza vremeni
   Serial.println("Regim-1");
digitalWrite(latchPin, 0);
shiftOut(dataPin, clockPin,MSBFIRST, second);
shiftOut(dataPin, clockPin,MSBFIRST, minute); 
shiftOut(dataPin, clockPin,MSBFIRST, hour);
digitalWrite(latchPin, 1);
   }
 ////////////////////////////////////////

////////////////////////////////////
 if(regim==2)
 {
  //regim ustanovki chasov
  Serial.println("Regim-2");
   H = hour;
   
   digitalWrite(latchPin, 0);
   shiftOut(dataPin, clockPin,MSBFIRST, second);
   shiftOut(dataPin, clockPin,MSBFIRST, minute); 
   shiftOut(dataPin, clockPin,MSBFIRST, H);
   digitalWrite(latchPin, 1);
   delay(400); //необходимо избавится
   digitalWrite(latchPin, 0);
   shiftOut(dataPin, clockPin,MSBFIRST, second);
   shiftOut(dataPin, clockPin,MSBFIRST, minute); 
   shiftOut(dataPin, clockPin,MSBFIRST, 0);
   digitalWrite(latchPin, 1);
   delay(400); //необходимо избавится
 
  if(digitalRead(Up)==HIGH&&flagUp==0)
  {
    Serial.println("H++");
    //H++; // как правильно?? так?
    H = H++; //или так?
    flag=1;
  }
    if(digitalRead(Up)==LOW&&flagUp==1)
  {
    flag=0;
  }
  if(digitalRead(Down)==HIGH&&flagDown==0)
  {
    Serial.println("H--");
    //H--; // как правильно?? так?
    H = H--; //или так?
    flagDown=1;
  }
    if(digitalRead(Down)==LOW&&flagDown==1)
  {
    flagDown=0;
  }
if(H > 23)
  {
    H = 0;
  }
if(H < 0);
  {
    H = 23;
  }
  /* Serial.println("Запись H в RTC");
   setDateTime;
byte hour = H; //0-23
Wire.beginTransmission(DS3231_ADDRESS);
Wire.write(0); //stop Oscillator
Wire.write(decToBcd(hour));
Wire.write(0); //start 
Wire.endTransmission();*/
 }
 ////////////////////////////////////

 ////////////////////////////////////
 
 if(regim==3)
 {
  //regim ustanovki minut
  Serial.println("Regim-3");
   M = minute;
   digitalWrite(latchPin, 0);
   shiftOut(dataPin, clockPin,MSBFIRST, second);
   shiftOut(dataPin, clockPin,MSBFIRST, M); 
   shiftOut(dataPin, clockPin,MSBFIRST, hour);
   digitalWrite(latchPin, 1);
   delay(400); //необходимо избавится
   digitalWrite(latchPin, 0);
   shiftOut(dataPin, clockPin,MSBFIRST, second);
   shiftOut(dataPin, clockPin,MSBFIRST, 0); 
   shiftOut(dataPin, clockPin,MSBFIRST, hour);
   digitalWrite(latchPin, 1);
   delay(400); //необходимо избавится

  if(digitalRead(Up)==HIGH&&flagUp==0)
  {
    Serial.println("M++");
    M = M++;
    flagUp=1;
  }
    if(digitalRead(Up)==LOW&&flagUp==1)
  {
    flagUp=0;
  }
  if(digitalRead(Down)==HIGH&&flagDown==0)
  {
    Serial.println("M--");
    M = M--;
    flagDown=1;
  }
    if(digitalRead(Down)==LOW&&flagDown==1)
  {
    flagDown=0;
  }
if(M > 59)
  {
    M = 0;
  }
if(M < 0);
  {
    M = 59;
  }
 }
}
 //////////////////////////////////////

 //////////////////////////////////////

и вообще я считаю чудом что мои скетчи хотя бы компилируются...

Таки давайте, пойдем мелкими шагами: Берем всю простыню и выкидываем в топку (пока).
Идем сюда и изучаем лисапед. Научившись ездить, добавляем в скетч две новых функции rtcWrite и rtcRead и  учимся с ними работать - считывать и записывать значения RTC. Читать-писать по одной переменной думаю не выйдет, только пачкой.
Освоили методы записи в RTC и начали придумывать алгоритм работы девайса - как попадаем в меню установки, как переходим, как  возвращаемся. Должно получиться - (условно) при длительном нажатии Set попали в выбор режима, Up Down Set - больше меньше переход, двойной или длинный Set - запись значений в RTC и возврат в основной режим (отображения).
Функцию изменения параметров, я бы сделал на while, с возможностью выхода по событию или таймеру (кстати в велосипеде вроде есть)
Всю эту радость делаем пока с выводом в сериал, не заморачиваясь с вашим экраном.
Наконец, написали функции вывода на ваш экран и вместо сериала передаем значения в них.

ну светодиодами моргать научился... ну не то что бы научился... примерно суть понял...

//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
// класс титановый велосипед для тактовой кнопки.
// фильтр дребезга, отслеживание событий: нажатие, отпускание, двойное нажатие(doubleclick), нажато и удерживается в течении определённого времени, отпущено и неактивно в течении определённого времени.

class BUTTON {
public:
//================================================================
static const byte bounce_              =   50; // длительность отслеживания дребезга.
static const byte doubleclick_         =  200; // длительность отслеживания двойного клика.
static const unsigned long timer_      = 5000; // длительность отслеживания неактивности.
static const unsigned int retention_   = 2000; // длительность отслеживания нажатия и удержания.
//================================================================
boolean click_down;
boolean click_up;
boolean doubleclick;
boolean timer;
boolean retention;
//=================================
unsigned long m;
boolean  p;
boolean  b;
boolean dc;
byte     c;
boolean  t;
boolean  r;
//=================================
byte _pb;
//=================================
BUTTON(byte pb) {
_pb = pb;
pinMode(_pb, INPUT);
digitalWrite(_pb, 1);
//====
click_down      = 0;
click_up        = 0;
doubleclick     = 0;
timer           = 0;
retention       = 0;
//====
m  =      millis();
p  = digitalRead(_pb);
b  =                0;
dc =                0;
c  =                0;
t  =                0;
r  =                0;
//====
}

void read() {
//=======================================================
unsigned long nm =      millis();
boolean       np = digitalRead(_pb);
//=================
boolean nb  = 0;
boolean ndc = 0;
boolean nt  = 0;
boolean nr  = 0;
//================
click_down  = 0;
click_up    = 0;
doubleclick = 0;
timer       = 0;
retention   = 0;
//=================
if (np != p) {p = np; m = nm; }
//=======================================================
if (nm - m > bounce_) {nb = 1;}
if (nm - m > doubleclick_) {ndc = 1;}
if (ndc != dc) {dc = ndc; if (dc == 1) {c = 0;}}
if (nb != b) {b = nb;
if (p == 0 && b == 0) {click_down = 1;
++c;      if (c == 2) {c = 0; doubleclick = 1;}
}
if (p == 1 && b == 1) {click_up = 1;}
}
//=======================================================
if (nm - m > timer_) {nt = 1;}
if (nt != t) {t = nt;
if (p == 1 && t == 1) {timer = 1;}
}
//=======================================================
if (nm - m > retention_) {nr = 1;}
if (nr != r) {r = nr;
if (p == 0 && r == 1) {retention = 1;}
}
//=======================================================
}
};
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

//~~~~~~~~~~~~~~~~~~~~
// здесь код приведённого выше класса class BUTTON {}; 
//~~~~~~~~~~~~~~~~~~~~

BUTTON BUTTON_01(5); // объявляем объект класса BUTTON кнопку с именем BUTTON_01, подключенную к пину 3.
BUTTON BUTTON_02(6); // объявляем объект класса BUTTON кнопку с именем BUTTON_02, подключенную к пину 4.
/*
//================================================================
static const byte bounce_              =   50; // длительность отслеживания дребезга.
static const byte doubleclick_         =  200; // длительность отслеживания двойного клика.
static const unsigned long timer_      = 5000; // длительность отслеживания неактивности.
static const unsigned int retention_   = 2000; // длительность отслеживания нажатия и удержания.
//================================================================
*/
void setup () {
  pinMode(9, OUTPUT);
  pinMode(10, OUTPUT);
  }

void loop() {

BUTTON_01.read(); // обновляем состояние переменных кнопки BUTTON_01.
BUTTON_02.read(); // обновляем состояние переменных кнопки BUTTON_02.

// работаем с переменными кнопки BUTTON_01.
if (BUTTON_01.click_down) {digitalWrite(10, HIGH);}
if (BUTTON_01.click_up) {digitalWrite(10, LOW);}
if (BUTTON_01.doubleclick) {digitalWrite(10, LOW);}
if (BUTTON_01.timer) {digitalWrite(10, HIGH);}
if (BUTTON_01.retention) {digitalWrite(10, HIGH);}

// работаем с переменными кнопки BUTTON_02.
if (BUTTON_02.click_down) {digitalWrite(9, LOW);}
if (BUTTON_02.click_up) {digitalWrite(9, HIGH);}
if (BUTTON_02.doubleclick) {digitalWrite(9, HIGH);}
if (BUTTON_02.timer) {digitalWrite(9, LOW);}
if (BUTTON_02.retention) {digitalWrite(9, LOW);}

}

Судя по коду, не научился :(

подскажите, а class BUTTON же можно как то в отдельный файл, и ссылку на него. Ну что то типа библиотеки

почему? он же загорается и гаснет как я ему говарю...

спрошу сразу пока не запутался еще дальше.

почему когда нажимаю вверх, переменная доходит до 23 и обнуляется, а когда нажимаю вниз, после нуля перескакивает на 255 и убавляется?

#include <Wire.h>
#include <DS3231.h>
DS3231 rtc(SDA, SCL);
Time RTC_Time;
byte h=0;
byte m=0;
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
// класс титановый велосипед для тактовой кнопки.
// фильтр дребезга, отслеживание событий: нажатие, отпускание, двойное нажатие(doubleclick), нажато и удерживается в течении определённого времени, отпущено и неактивно в течении определённого времени.

class BUTTON {
public:
//================================================================
static const byte bounce_              =   50; // длительность отслеживания дребезга.
static const byte doubleclick_         =  200; // длительность отслеживания двойного клика.
static const unsigned long timer_      = 5000; // длительность отслеживания неактивности.
static const unsigned int retention_   = 2000; // длительность отслеживания нажатия и удержания.
//================================================================
boolean click_down;
boolean click_up;
boolean doubleclick;
boolean timer;
boolean retention;
//=================================
unsigned long m;
boolean  p;
boolean  b;
boolean dc;
byte     c;
boolean  t;
boolean  r;
//=================================
byte _pb;
//=================================
BUTTON(byte pb) {
_pb = pb;
pinMode(_pb, INPUT);
digitalWrite(_pb, 1);
//====
click_down      = 0;
click_up        = 0;
doubleclick     = 0;
timer           = 0;
retention       = 0;
//====
m  =      millis();
p  = digitalRead(_pb);
b  =                0;
dc =                0;
c  =                0;
t  =                0;
r  =                0;
//====
}

void read() {
//=======================================================
unsigned long nm =      millis();
boolean       np = digitalRead(_pb);
//=================
boolean nb  = 0;
boolean ndc = 0;
boolean nt  = 0;
boolean nr  = 0;
//================
click_down  = 0;
click_up    = 0;
doubleclick = 0;
timer       = 0;
retention   = 0;
//=================
if (np != p) {p = np; m = nm; }
//=======================================================
if (nm - m > bounce_) {nb = 1;}
if (nm - m > doubleclick_) {ndc = 1;}
if (ndc != dc) {dc = ndc; if (dc == 1) {c = 0;}}
if (nb != b) {b = nb;
if (p == 0 && b == 0) {click_down = 1;
++c;      if (c == 2) {c = 0; doubleclick = 1;}
}
if (p == 1 && b == 1) {click_up = 1;}
}
//=======================================================
if (nm - m > timer_) {nt = 1;}
if (nt != t) {t = nt;
if (p == 1 && t == 1) {timer = 1;}
}
//=======================================================
if (nm - m > retention_) {nr = 1;}
if (nr != r) {r = nr;
if (p == 0 && r == 1) {retention = 1;}
}
//=======================================================
}
};
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

//~~~~~~~~~~~~~~~~~~~~
// здесь код приведённого выше класса class BUTTON {}; 
//~~~~~~~~~~~~~~~~~~~~

BUTTON Set(5); // объявляем объект класса BUTTON кнопку с именем BUTTON_01, подключенную к пину 5.
BUTTON Up(6); // объявляем объект класса BUTTON кнопку с именем BUTTON_02, подключенную к пину 6.
BUTTON Down(7); // объявляем объект класса BUTTON кнопку с именем BUTTON_03, подключенную к пину 7.

void setup () {
  Serial.begin(9600);
  Wire.begin();
  rtc.begin();
  pinMode(9, OUTPUT);
  pinMode(10, OUTPUT);

  }

void loop() {


  //Вывод времени.
  Serial.println(rtc.getTimeStr());
  //delay(1000);

Set.read(); // обновляем состояние переменных кнопки Set.
Up.read(); // обновляем состояние переменных кнопки Up.
Down.read(); // обновляем состояние переменных кнопки Down.

if (Up.click_down) {h = ++h;
if(h > 23)  {h = 0;}}

if (Down.click_down) {h = --h;
if(h < 0)  {h = 23;}}

if (Set.timer) {rtc.setTime(h, m, 00);}
Serial.println(h);
}

хм...... сделал их (int), все заработало.....

простите что я такой балбес((

Потому, что h у Вас byte - т.е. беззнаковое целое. И какй смысл сравнивать его на < 0 в строке 130? Оно никогда меньше не будет, дойдёт до 0 и станет 255.

ну вот вроде как сделал что то такое. по крайне мере время устанавливаю...

пока коряво конечно, но все же

#include <TimeHelpers.h>
#include <Wire.h>
#include <DS3231.h>
DS3231 rtc(SDA, SCL);
Time RTC_Time;
#define DS3231_ADDRESS 0x68
int latchPin = 11;
int clockPin = 13;
int dataPin = 12;
int h=0;
int m=0;
int regim=1;
#define PRINT_INTERVAL 400UL
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
// класс титановый велосипед для тактовой кнопки.
// фильтр дребезга, отслеживание событий: нажатие, отпускание, двойное нажатие(doubleclick), нажато и удерживается в течении определённого времени, отпущено и неактивно в течении определённого времени.

class BUTTON {
public:
//================================================================
static const byte bounce_              =   50; // длительность отслеживания дребезга.
static const byte doubleclick_         =  200; // длительность отслеживания двойного клика.
static const unsigned long timer_      = 5000; // длительность отслеживания неактивности.
static const unsigned int retention_   = 2000; // длительность отслеживания нажатия и удержания.
//================================================================
boolean click_down;
boolean click_up;
boolean doubleclick;
boolean timer;
boolean retention;
//=================================
unsigned long m;
boolean  p;
boolean  b;
boolean dc;
byte     c;
boolean  t;
boolean  r;
//=================================
byte _pb;
//=================================
BUTTON(byte pb) {
_pb = pb;
pinMode(_pb, INPUT);
digitalWrite(_pb, 1);
//====
click_down      = 0;
click_up        = 0;
doubleclick     = 0;
timer           = 0;
retention       = 0;
//====
m  =      millis();
p  = digitalRead(_pb);
b  =                0;
dc =                0;
c  =                0;
t  =                0;
r  =                0;
//====
}

void read() {
//=======================================================
unsigned long nm =      millis();
boolean       np = digitalRead(_pb);
//=================
boolean nb  = 0;
boolean ndc = 0;
boolean nt  = 0;
boolean nr  = 0;
//================
click_down  = 0;
click_up    = 0;
doubleclick = 0;
timer       = 0;
retention   = 0;
//=================
if (np != p) {p = np; m = nm; }
//=======================================================
if (nm - m > bounce_) {nb = 1;}
if (nm - m > doubleclick_) {ndc = 1;}
if (ndc != dc) {dc = ndc; if (dc == 1) {c = 0;}}
if (nb != b) {b = nb;
if (p == 0 && b == 0) {click_down = 1;
++c;      if (c == 2) {c = 0; doubleclick = 1;}
}
if (p == 1 && b == 1) {click_up = 1;}
}
//=======================================================
if (nm - m > timer_) {nt = 1;}
if (nt != t) {t = nt;
if (p == 1 && t == 1) {timer = 1;}
}
//=======================================================
if (nm - m > retention_) {nr = 1;}
if (nr != r) {r = nr;
if (p == 0 && r == 1) {retention = 1;}
}
//=======================================================
}
};
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

//~~~~~~~~~~~~~~~~~~~~
// здесь код приведённого выше класса class BUTTON {}; 
//~~~~~~~~~~~~~~~~~~~~

BUTTON Set(5); // объявляем объект класса BUTTON кнопку с именем BUTTON_01, подключенную к пину 5.
BUTTON Up(6); // объявляем объект класса BUTTON кнопку с именем BUTTON_02, подключенную к пину 6.
BUTTON Down(7); // объявляем объект класса BUTTON кнопку с именем BUTTON_03, подключенную к пину 7.


void setup () {
  Serial.begin(9600);
  Wire.begin();
  rtc.begin();
  pinMode(latchPin, OUTPUT);
  pinMode(clockPin, OUTPUT);
  pinMode(dataPin, OUTPUT);

  }

void loop() {
  printDate();
//delay(1000);
}

byte decToBcd(byte val){
// Convert normal decimal numbers to binary coded decimal
return ( (val/10*16) + (val%10) );
}
byte bcdToDec(byte val) {
// Convert binary coded decimal to normal decimal numbers
return ( (val/16*10) + (val%16) );
}
void printDate(){
// Reset the register pointer
Wire.beginTransmission(DS3231_ADDRESS);
Wire.write(0);
Wire.endTransmission();
Wire.requestFrom(DS3231_ADDRESS, 7);
int second = bcdToDec(Wire.read());
int minute = bcdToDec(Wire.read());
int hour = bcdToDec(Wire.read() & 0b111111); //24 hour time
int dow = bcdToDec(Wire.read()); //0-6 -> sunday — Saturday
int day = bcdToDec(Wire.read());
int month = bcdToDec(Wire.read());
int year = bcdToDec(Wire.read());
int getTemp = bcdToDec(Wire.read());

Set.read(); // обновляем состояние переменных кнопки Set.
Up.read(); // обновляем состояние переменных кнопки Up.
Down.read(); // обновляем состояние переменных кнопки Down.

if (Set.timer) 
{regim++;
if(regim>3){regim=1;}}

if(regim==1){
    //Вывод времени.
    DO_EVERY(PRINT_INTERVAL,{
    Serial.println(rtc.getTimeStr());
    Serial.println("Regim-1");
    });
    digitalWrite(latchPin, LOW);
    shiftOut(dataPin, clockPin,MSBFIRST, second);
    shiftOut(dataPin, clockPin,MSBFIRST, minute); 
    shiftOut(dataPin, clockPin,MSBFIRST, hour);
    digitalWrite(latchPin, HIGH);}

if(regim==2){
    DO_EVERY(PRINT_INTERVAL,{
    Serial.println("Regim-2");
    Serial.println(h);

    digitalWrite(latchPin, LOW);
    shiftOut(dataPin, clockPin,MSBFIRST, second);
    shiftOut(dataPin, clockPin,MSBFIRST, minute);
    shiftOut(dataPin, clockPin,MSBFIRST, h);
    digitalWrite(latchPin, HIGH);

    digitalWrite(latchPin, LOW);
    shiftOut(dataPin, clockPin,MSBFIRST, second);
    shiftOut(dataPin, clockPin,MSBFIRST, minute);
    shiftOut(dataPin, clockPin,MSBFIRST, 0);
    digitalWrite(latchPin, HIGH);
    });

    if (Up.click_down) {h = ++h;
    if(h > 23)  {h = 0;}}
    if (Down.click_down) {h = --h;
    if(h < 0)  {h = 23;}}
    if (Set.doubleclick) {rtc.setTime(h, m, 00);
    regim=1;}}


if(regim==3){
    DO_EVERY(PRINT_INTERVAL,{
    Serial.println("Regim-3");
    Serial.println(m);

    digitalWrite(latchPin, LOW);
    shiftOut(dataPin, clockPin,MSBFIRST, second);
    shiftOut(dataPin, clockPin,MSBFIRST, m);
    shiftOut(dataPin, clockPin,MSBFIRST, hour);
    digitalWrite(latchPin, HIGH);

    digitalWrite(latchPin, LOW);
    shiftOut(dataPin, clockPin,MSBFIRST, second);
    shiftOut(dataPin, clockPin,MSBFIRST, 0);
    shiftOut(dataPin, clockPin,MSBFIRST, hour);
    digitalWrite(latchPin, HIGH);
    });
    
    if (Up.click_down) {m = ++m;
    if(m > 59)  {m = 0;}}
    if (Down.click_down) {m = --m;
    if(m < 0)  {m = 59;}}
    if (Set.doubleclick) {rtc.setTime(h, m, 00);
    regim=1;}}

}

и да ... как все таки класс то отдельно сделать? а то он так страшно в коде смотрится

ах да... еще не знаю как сделать что бы "h" и "m" по умолчанию были часы и минуты, что бы включил настройку, и переводиш часы с текущего времени, а не со значения переменной.

Не хотите вы с мечтой, все в одну кучу спихать, расставаться. Вошли в режим изменения, считали значения с RTC, приравняли им H и M.

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

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

time = 1 Апреля

и, всё!

не, эт фигня получится, и время не точно, и при потере питания сбивается...

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

#include <ButtonHelper.h>
#include <TimeHelpers.h>
#include <Wire.h>
#include <DS3231.h>
DS3231 rtc(SDA, SCL);
Time RTC_Time;
#define DS3231_ADDRESS 0x68
int latchPin = 11;
int clockPin = 13;
int dataPin = 12;
int h=0;
int m=0;
int regim=1;
#define PRINT_INTERVAL 500UL

BUTTON Set(5); // объ¤вл¤ем объект класса BUTTON кнопку с именем BUTTON_01, подключенную к пину 5.
BUTTON Up(6); // объ¤вл¤ем объект класса BUTTON кнопку с именем BUTTON_02, подключенную к пину 6.
BUTTON Down(7); // объ¤вл¤ем объект класса BUTTON кнопку с именем BUTTON_03, подключенную к пину 7.


void setup () {
  Serial.begin(9600);
  Wire.begin();
  rtc.begin();
  pinMode(latchPin, OUTPUT);
  pinMode(clockPin, OUTPUT);
  pinMode(dataPin, OUTPUT);
  }

void loop() {
  printDate();
//delay(1000);
}

byte decToBcd(byte val){
// Convert normal decimal numbers to binary coded decimal
return ( (val/10*16) + (val%10) );
}
byte bcdToDec(byte val) {
// Convert binary coded decimal to normal decimal numbers
return ( (val/16*10) + (val%16) );
}
void printDate(){
// Reset the register pointer
Wire.beginTransmission(DS3231_ADDRESS);
Wire.write(0);
Wire.endTransmission();
Wire.requestFrom(DS3231_ADDRESS, 7);
int second = bcdToDec(Wire.read());
int minute = bcdToDec(Wire.read());
int hour = bcdToDec(Wire.read() & 0b111111); //24 hour time
int dow = bcdToDec(Wire.read()); //0-6 -> sunday Ч Saturday
int day = bcdToDec(Wire.read());
int month = bcdToDec(Wire.read());
int year = bcdToDec(Wire.read());
int getTemp = bcdToDec(Wire.read());

Set.read(); // обновл¤ем состо¤ние переменных кнопки Set.
Up.read(); // обновл¤ем состо¤ние переменных кнопки Up.
Down.read(); // обновл¤ем состо¤ние переменных кнопки Down.

if (Set.timer) 
{regim++;
if(regim>3){regim=1;}}

if(regim==1){
    //¬ывод времени.
    DO_EVERY(PRINT_INTERVAL,{
    Serial.println(rtc.getTimeStr());
    Serial.println("Regim-1");
    });
    digitalWrite(latchPin, LOW);
    shiftOut(dataPin, clockPin,MSBFIRST, second);
    shiftOut(dataPin, clockPin,MSBFIRST, minute); 
    shiftOut(dataPin, clockPin,MSBFIRST, hour);
    digitalWrite(latchPin, HIGH);}

if(regim==2){
    DO_EVERY(PRINT_INTERVAL,{
    Serial.println("Regim-2");
    Serial.println(h);
    digitalWrite(latchPin, LOW);
    shiftOut(dataPin, clockPin,MSBFIRST, second);
    shiftOut(dataPin, clockPin,MSBFIRST, minute);
    shiftOut(dataPin, clockPin,MSBFIRST, h);
    digitalWrite(latchPin, HIGH);});
    digitalWrite(latchPin, LOW);
    shiftOut(dataPin, clockPin,MSBFIRST, second);
    shiftOut(dataPin, clockPin,MSBFIRST, minute);
    shiftOut(dataPin, clockPin,MSBFIRST, 0);
    digitalWrite(latchPin, HIGH);
    if (Up.click_down) {h = ++h;
    if(h > 23)  {h = 0;}}
    if (Down.click_down) {h = --h;
    if(h < 0)  {h = 23;}}
    if (Set.doubleclick) {rtc.setTime(h, minute, 00);
    regim=1;}}


if(regim==3){
    DO_EVERY(PRINT_INTERVAL,{
    Serial.println("Regim-3");
    Serial.println(m);
    digitalWrite(latchPin, LOW);
    shiftOut(dataPin, clockPin,MSBFIRST, second);
    shiftOut(dataPin, clockPin,MSBFIRST, m);
    shiftOut(dataPin, clockPin,MSBFIRST, h);
    digitalWrite(latchPin, HIGH);});
    digitalWrite(latchPin, LOW);
    shiftOut(dataPin, clockPin,MSBFIRST, second);
    shiftOut(dataPin, clockPin,MSBFIRST, 0);
    shiftOut(dataPin, clockPin,MSBFIRST, h);
    digitalWrite(latchPin, HIGH);
    if (Up.click_down) {m = ++m;
    if(m > 59)  {m = 0;}}
    if (Down.click_down) {m = --m;
    if(m < 0)  {m = 59;}}
    if (Set.doubleclick) {rtc.setTime(h, m, 00);
    regim=1;}}
}

Господа! Так как все таки присвоить переменной "h" и "m", что бы они стали равны часам и минутам, но при этом менялись?

А то я присваиваю им значение часов и минут, а они его постоянно считывают, и не меняются(

Теоретически,  m = minute;
А проблема думаю от того, что все время крутитесь в loop, при каждом проходе считываете их по новой и каждый раз возвращаетесь в выбор режима. Они бы и хотели поменяться, да никак.((((

И что у вас в 62 строке за переменная? Откуда она берется, не нашел.

А в строках 96 и 118  сохранение корректно написано? А то считываете через Wire, а записываете иначе?

Не знаю, но время записывается, проблем с этим вроде нет.

Ох... и все равно не могу понять как адекватно мигать переменной. Это не совсем тоже самое что мигать одним диодом, тут как то через ж... надо.

так красиво но не работает как надо

    digitalWrite(latchPin, LOW);
    shiftOut(dataPin, clockPin,MSBFIRST, second);
    shiftOut(dataPin, clockPin,MSBFIRST, minute);
    shiftOut(dataPin, clockPin,MSBFIRST, h);
    digitalWrite(latchPin, HIGH);
    delay(500);
    digitalWrite(latchPin, LOW);
    shiftOut(dataPin, clockPin,MSBFIRST, second);
    shiftOut(dataPin, clockPin,MSBFIRST, minute);
    shiftOut(dataPin, clockPin,MSBFIRST, 0);
    digitalWrite(latchPin, HIGH);

а так мигает черте как, редко и тускло, не так, горит пол секунды - не горит по секунды, а вспыхивает каждые пол секунды на мгновение

    if(millis() - previousMillis > 500){
    previousMillis = millis();
    digitalWrite(latchPin, LOW);
    shiftOut(dataPin, clockPin,MSBFIRST, second);
    shiftOut(dataPin, clockPin,MSBFIRST, minute);
    shiftOut(dataPin, clockPin,MSBFIRST, h);
    digitalWrite(latchPin, HIGH);
}
    digitalWrite(latchPin, LOW);
    shiftOut(dataPin, clockPin,MSBFIRST, second);
    shiftOut(dataPin, clockPin,MSBFIRST, minute);
    shiftOut(dataPin, clockPin,MSBFIRST, 0);
    digitalWrite(latchPin, HIGH);

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

голова болит, пошел спать((