Таймер обратного отсчета СЕКУНДА-2 на ARDUINO с памятью на 20 значений, от 1с до 99 часов. Для: УФ - сушилки, Фоторезиста, Шеллака, Печатей

Таймер обратного отсчета СЕКУНДА-2

На ARDUINO с памятью на 20 значений, от 1с до 99 часов.

Для: УФ - сушилки, Фоторезиста, Шеллака, Печатей 

СКЕТЧ https://yadi.sk/d/yP6Qu2_MwuQgE

Нажми что бы открыть СКЕТЧ:

#include <EEPROM.h>
#include <LiquidCrystal.h>

// пины ЖК индикатора, rs, enable, d4, d5, d6, d7
LiquidCrystal lcd(4, 5, 6, 7, 8, 9);

// пины энкодера. Для atmega 168/328 PIN_A должен быть на 2 или 3 пине (для работы прерывания)
#define ENC_PIN_A 2
#define ENC_PIN_B 3
#define ENC_PIN_BTN 12
// пин кнопки старт/стоп
#define START_PIN 11
// пин, управляющий реле нагрузки
#define RELAY 13
// пин, управляющий пищалкой
#define BEEPER 10

// номер прерывания для пина А энкодера. 
//#define ENC_PIN_A_INTERRUPT digitalPinToInterrupt(ENC_PIN_A)
// если строка выше не пашет, можно задать вручную. Для пина 2 - номер 0
#define ENC_PIN_A_INTERRUPT 0

// интервал мигания в миллисекундах
#define BLINK_MS 600

// длительность длинного нажатия в миллисекундах
#define LONG_PRESS_MS 1000

uint8_t h, m, s; // hours, minutes, seconds
uint8_t prg; // номер текущей программы (ячейки памяти)
unsigned long start_time; // время начала отсчёта текущей секунды
uint8_t working; // флаг работы, 1 - идёт отсчёт
uint8_t selection; // текущее выбраное для редактирования поле, одно из:
#define HOURS 1
#define MINS 2
#define SECS 3
#define PROG 4
#define LAST 4

// количество программ
#define MAX_PROG 20

// Частота пищания в Гц
#define BEEPER_FREQ 1000
// Длительность бипа в секундах
#define BEEP_LENGTH 1

// адреса сохранённых программ в EEPROM
#define EEPROM_PRG_H(_prg) (_prg*3+0)
#define EEPROM_PRG_M(_prg) (_prg*3+1)
#define EEPROM_PRG_S(_prg) (_prg*3+2)

// чтение ч, м, с текущей программы из EEPROM
#define PRG_H (EEPROM.read(EEPROM_PRG_H(prg)))
#define PRG_M (EEPROM.read(EEPROM_PRG_M(prg)))
#define PRG_S (EEPROM.read(EEPROM_PRG_S(prg)))

typedef struct Button
{
	uint8_t last_state; // прошлое состояние кнопки
	unsigned long last_change; // время последнего изменения состояния кнопки
	uint8_t press; // флаг нажатия на кнопку
	uint8_t long_press; // флаг длинного нажатия на кнопку
} Button;

typedef struct Encoder
{
	uint8_t last_state_A, last_state_B; // прошлое состояние входов
	int8_t pos; // относительное значение энкодера, без очистки от дребезга
	volatile int8_t value; // относительное значение энкодера, отфильтрованное
} Encoder;

Button btn_enc;
Button btn_start;
Encoder encoder;

bool ProgramValid()
// проверяет текущую программу на корректность. По умолчанию в EEPROMе лежат сплошные 0xFF (255).
{
	return (PRG_H<100) && (PRG_M<60) && (PRG_S<60);
}
	
void DisplayAll()
{
  uint8_t blink;
  
  blink=(millis() % BLINK_MS) < BLINK_MS/2; // Определяем, какая сейчас половина интервала мигания
	if (working) blink=1; // если работаем, то нефиг мигать
  
  //lcd.clear();
  lcd.setCursor(0, 0);
  if (blink || (selection!=HOURS))
  {
    lcd.write((h / 10)+'0');
    lcd.write((h % 10)+'0');
    lcd.write('h');
  } else lcd.print("   ");
  if (blink || (selection!=MINS))
  {
    lcd.write((m / 10)+'0');
    lcd.write((m % 10)+'0');
    lcd.write('m');
  } else lcd.print("   ");
  if (blink || (selection!=SECS))
  {
    lcd.write((s / 10)+'0');
    lcd.write((s % 10)+'0');
    lcd.write('s');
  } else lcd.print("   ");
  
  uint16_t sm, i;
  char buf[]="     0s"; // "  0000s"
  
  // далее отображаем время в секундах, для справки
  // меньше двух часов дублируем в секундах, больше - в минутах
  if (h>=2)
  {
    sm=(uint16_t)h*60+m; 
    buf[6]='m';
  }
  else 
  {
    sm=(uint16_t)h*3600 + m*60 + s;
    buf[6]='s';
  }
  i=5;
  do
  {
    buf[i--]=((sm % 10)+'0');
    sm=sm/10;
  } while (sm>0 && i>0);
  lcd.print(&buf[0]);
	
	// вторая строка
  lcd.setCursor(0, 1);
	
	// номер программы
	lcd.write('[');
  if (blink || (selection!=PROG))
  {
    lcd.write((prg / 10)+'0');
    lcd.write((prg % 10)+'0');
  } else lcd.print("  ");
  lcd.write(']');
  lcd.write(' ');
	
	// это для отладки энкодера
	//if (digitalRead(ENC_PIN_A)) lcd.write('A'); else lcd.write(' ');
	//if (digitalRead(ENC_PIN_B)) lcd.write('B'); else lcd.write(' ');

	// длительность текущей программы
	if (ProgramValid())
	{
		lcd.write((PRG_H / 10)+'0');
		lcd.write((PRG_H % 10)+'0');
		lcd.write('h');
		lcd.write((PRG_M / 10)+'0');
		lcd.write((PRG_M % 10)+'0');
		lcd.write('m');
		lcd.write((PRG_S / 10)+'0');
		lcd.write((PRG_S % 10)+'0');
		lcd.write('s');
	} else
		lcd.print("--h--m--s");
}

// третье состояние кнопки (первые два LOW и HIGH), означает длинное нажатие, на которое мы уже отреагировали
#define STATE_WAIT 3

void ProcessButton(struct Button& btn, uint8_t state)
{
	// проверяем, если кнопка всё ещё нажата, а длинное нажатие уже отработано, то ничего не делаем
	if (state==LOW && btn.last_state==STATE_WAIT) return;
	
	// проверяем, изменилось ли состояние кнопки
	if (btn.last_state != state)
	{ // изменилось
		// если кнопку отменили, а длинного нажатия ещё не было, значит ставим флаг простого клика
		if (state==HIGH && btn.last_state!=STATE_WAIT) btn.press=1;
		btn.last_change=millis();
		btn.last_state=state;
	}
	else
	{ // ничего не изменилось. Проверяем, не удерживают ли кнопку дольще определенного порога?
		if (state==LOW && btn.last_state!=STATE_WAIT && (millis()-btn.last_change) > LONG_PRESS_MS)
		{ // да, это длинный клик. Ставим флаг длинного клика и отмечаем что клик уже отработан в состоянии кнопки
			btn.long_press=1;
			btn.last_state=STATE_WAIT;
		}
	}			
}

void ProcessEncoder(struct Encoder& enc, uint8_t state_A, uint8_t state_B)
{
	if (enc.last_state_A == state_A /*&& enc.last_state_B==state_B*/) return; // ничего не изменилось, уходим
	
	if (state_A == state_B) enc.pos--; else enc.pos++;
	
	if (enc.pos>=2)
	{
		enc.pos=0;
		enc.value++;
	}
	if (enc.pos<=-2)
	{
		enc.pos=0;
		enc.value--;
	}
	
	enc.last_state_A=state_A;
	enc.last_state_B=state_B;
}

void CheckButtons()
{
	ProcessButton(btn_enc, digitalRead(ENC_PIN_BTN));
	ProcessButton(btn_start, digitalRead(START_PIN));
}

void EncoderRotated()
// обработчик прерывания от энкодера
{
	ProcessEncoder(encoder, digitalRead(ENC_PIN_A), digitalRead(ENC_PIN_B));
}

void SaveProg()
// сохраняет текущее время в текущую программу
{
	EEPROM.write(EEPROM_PRG_H(prg), h);
	EEPROM.write(EEPROM_PRG_M(prg), m);
	EEPROM.write(EEPROM_PRG_S(prg), s);
}

void LoadProgram()
// загружает текущую программу
{
  if (ProgramValid()) 
	{ 
		h=PRG_H; 
		m=PRG_M; 
		s=PRG_S; 
	}	
}

void PowerOn()
{
	digitalWrite(RELAY, HIGH);
}

void PowerOff()
{
	digitalWrite(RELAY, LOW);
}

void Beeeeeeeep()
{
	// мерзко бибипкнуть подольше
	int i;
	
	for (i=0; i<BEEPER_FREQ*BEEP_LENGTH; i++)
	{
		digitalWrite(BEEPER, HIGH);
		delayMicroseconds(500000/BEEPER_FREQ);
		digitalWrite(BEEPER, LOW);
		delayMicroseconds(500000/BEEPER_FREQ);
	}
}

void Beep()
{
	// короткий бип
	int i;
	
	for (i=0; i<BEEPER_FREQ/20; i++)
	{
		digitalWrite(BEEPER, HIGH);
		delayMicroseconds(500000/BEEPER_FREQ);
		digitalWrite(BEEPER, LOW);
		delayMicroseconds(500000/BEEPER_FREQ);
	}
}

void Start()
// запускаем отсчёт, включаем нагрузку
{
	if (h==0 && m==0 && s==0) return; // если отсчитывать нечего, тогда и не запускаемся
	working=1;
	Beep();
	start_time=millis(); // запоминаем время начала отсчёта
	PowerOn();
}

void Stop()
// останавливаем отсчёт, выключаем нагрузку
{
	working=0;
	PowerOff();
	// если дошли до нуля (счёт окончен, а не просто пауза кнопкой), то перезапускаем таймер
	if (h==0 && m==0 && s==0)
	{
		Beeeeeeeep();
		LoadProgram();
	} else Beep();
}

void setup()
{
	lcd.begin(16, 2);
  selection=PROG;
  h=0;
  m=0;
  s=0;
	working=0;
	// устанавливаем пины от кнопок в режим входов
	pinMode(ENC_PIN_A, INPUT);
	pinMode(ENC_PIN_B, INPUT);
	pinMode(ENC_PIN_BTN, INPUT);
	pinMode(START_PIN, INPUT);
	// включаем подтяжку к питанию
	digitalWrite(ENC_PIN_A, HIGH);
	digitalWrite(ENC_PIN_B, HIGH);
	digitalWrite(ENC_PIN_BTN, HIGH);
	digitalWrite(START_PIN, HIGH);

	// пин управления реле нагрузки
	PowerOff();
	pinMode(RELAY, OUTPUT);

	// пин управления пищалкой
	pinMode(BEEPER, OUTPUT);
	digitalWrite(BEEPER, LOW);
	
  // начальное состояние кнопок - не нажаты
	btn_enc.last_state=HIGH;
	btn_start.last_state=HIGH;
	encoder.last_state_A=HIGH;
	encoder.last_state_B=HIGH;
	
	LoadProgram();
	
	// вешаем прерывание на пин А энкодера. Обработчик - EncoderRotated()
	attachInterrupt(ENC_PIN_A_INTERRUPT, EncoderRotated, CHANGE);
}

void loop()
{
	if (working && (millis()-start_time >= 1000))
	{ // прошло больше секунды, уменьшаем
		// сдвигаем время начала на секунду вперёд, а время уменьшаем на секунду
		start_time=start_time+1000;
		if (s>0) s--;
		else
		{
			s=59;
			if (m>0) m--;
			else
			{
				m=59;
				if (h>0) h--;
				else h=m=s=0;
			}
		}
	}

	DisplayAll();

	if (working && h==0 && m==0 && s==0) Stop(); // дошли до нуля
	
	CheckButtons();
	
	// кнопка старт/стоп
	if (btn_start.press)
	{
		if (working) Stop(); else Start();
		btn_start.press=0;
	}
	if (btn_start.long_press)
	{
		// в режиме паузы перезагружаем время из программы
		if (!working)
		{
			LoadProgram();
			Beep();
		}
		btn_start.long_press=0;
	}
	
	// кнопка энкодера
	if (btn_enc.press && !working)
	{
		selection++;
		if (selection>LAST) selection=1;
	}
	btn_enc.press=0;
	if (btn_enc.long_press && !working)
	{
		if (selection==PROG) { h=m=s=0; /*SaveProg();*/ }
		if (selection==HOURS || selection==MINS || selection==SECS) { SaveProg(); }
		Beep();
	}
	btn_enc.long_press=0;
	
	// энкодер
	if (encoder.value != 0 && !working)
	{
		if (selection==HOURS) h=(h+100+encoder.value) % 100;
		if (selection== MINS) m=(m+ 60+encoder.value) %  60;
		if (selection== SECS) s=(s+ 60+encoder.value) %  60;
		if (selection== PROG) 
		{
			prg=(prg+MAX_PROG+encoder.value) %  MAX_PROG;
			LoadProgram();
		}
	}
	encoder.value=0;
  delay(10);
}