Digispark в коробочке

// Генератор импульсов, ksiman © //

int flag = 0; //объявление переменных и их тип
int mode = 1;
unsigned long time1 = 0;
unsigned long time2 = 0;

void setup()
{
  pinMode(3, INPUT); //настройка входа
  pinMode(1, OUTPUT); //настройка выхода
}

void loop()
{
  if (digitalRead(3) == LOW && flag == 0) //проверка нажатой кнопки и флага
  {
    delay(500); //задержка для контроля удержания кнопки 500мс
    mode++; //следующий режим работы
    flag = 1; //установка флага

    if (digitalRead(3) == LOW) //кнопка всё ещё нажата?
    {
      delay(50); //защита от дребезга контакта 50мс
      mode = 1; //возврат в 1 режим работы
    }

    if (mode > 6) //количество режимов работы
    {
      mode = 1; //зацикливание смены режимов работы
    }
  }

  if (digitalRead(3) == HIGH && flag == 1) //проверка не нажатой кнопки и флага
  {
    flag = 0; //сброс флага
  }

  //---------------------------------------------------------------------

  if (mode == 1) //1 режим работы
  {
    digitalWrite(1, HIGH); //постоянный сигнал на выходе
  }

  //---------------------------------------------------------------------

  if (mode == 2) //2 режим работы
  {
    if (millis() - time1 > 2000) //период следования импульсов 2000мс
    {
      time1 = millis();
      digitalWrite(1, LOW);
      time2 = millis();
    }
    if (millis() - time2 > 1000) //длительность импульсов 1000мс
    {
      digitalWrite(1, HIGH);
      time2 = millis();
    }
  }

  //---------------------------------------------------------------------

  if (mode == 3) //3 режим работы
  {
    if (millis() - time1 > 1000) //период следования импульсов 1000мс
    {
      time1 = millis();
      digitalWrite(1, LOW);
      time2 = millis();
    }
    if (millis() - time2 > 100) //длительность импульсов 100мс
    {
      digitalWrite(1, HIGH);
      time2 = millis();
    }
  }

  //---------------------------------------------------------------------

  if (mode == 4) //4 режим работы
  {
    if (millis() - time1 > 1000) //период следования импульсов 1000мс
    {
      time1 = millis();
      digitalWrite(1, LOW);
      time2 = millis();
    }
    if (millis() - time2 > 900) //длительность импульсов 900мс
    {
      digitalWrite(1, HIGH);
      time2 = millis();
    }
  }

  //---------------------------------------------------------------------

  if (mode == 5) //5 режим работы
  {
    if (millis() - time1 > 200) //период следования импульсов 200мс
    {
      time1 = millis();
      digitalWrite(1, LOW);
      time2 = millis();
    }
    if (millis() - time2 > 100) //длительность импульсов 100мс
    {
      digitalWrite(1, HIGH);
      time2 = millis();
    }
  }
  
  //---------------------------------------------------------------------

  if (mode == 6) //6 режим работы
  {
    if (millis() - time1 > 100) //период следования импульсов 100мс
    {
      time1 = millis();
      digitalWrite(1, LOW);
      time2 = millis();
    }
    if (millis() - time2 > 50) //длительность импульсов 50мс
    {
      digitalWrite(1, HIGH);
      time2 = millis();
    }
  }
}

// Генератор импульсов,  © yurok  //
// конфигурация пинов
#define BUTTON_PIN 3
#define SIGNAL_PIN 1

#define BOUNCE_PROTECTION_TIME 50 // защита от дребезга, мс
#define LONG_BUTTON_TIME 500 // длительность длинного нажатия, мс

byte CurrentMode = 0; // начинаем с первого режима
byte MaxMode = 0; // максимальное количество режимов в приборе
unsigned long TimePeriod = 0; // время последней фиксации периода
bool ButtonFlag = false; // нажата ли клавиша сейчас
bool PulseFlag = false; // признак того, что в текущем периоде импульс уже выдавали

// создаем тип данных "режим"
typedef struct
{
  unsigned long Period; // период
  unsigned long Duration; // длительность импульса
}
ModeType;
ModeType MT[] = { // массив структур режимов
  {1,    0},    // 1 режим (постоянный сигнал)
  {2000, 1000}, // 2 режим (меандр 0,5Гц)
  {1000, 100},  // 3 режим (короткий импульс)
  {1000, 900},  // 4 режим (короткая пауза)
  {200,  100},  // 5 режим (меандр 5Гц)
  {100,  50}    // 6 режим (меандр 10Гц)
};

// определение количества элементов в массиве произвольного типа
template<typename T, size_t n> inline size_t arraySize(const T (&arr)[n])
{
  return n;
}

////////////////////////////////////////////////////////////////////////////////
// предварительная настройка программы
////////////////////////////////////////////////////////////////////////////////
void setup()
{
  pinMode(BUTTON_PIN, INPUT); // кнопка
  pinMode(SIGNAL_PIN, OUTPUT); //сигнал
  MaxMode = arraySize(MT) - 1; // вычисляем максимальный доступный режим
}

////////////////////////////////////////////////////////////////////////////////
// функция для генерации импульсов в зависимости от режима
////////////////////////////////////////////////////////////////////////////////
void mode_control(byte in_mode) // первый режим не требует контроля времени, поэтому отработаем его тут
{
  if (in_mode == 0)
  {
    digitalWrite(SIGNAL_PIN, HIGH);
    return;
  }

  // все другие режимы отрабатываются одинаково
  unsigned long CurrentTime = millis(); // текущее время
  // проверка окончания прошлого периода
  if (CurrentTime - TimePeriod > MT[in_mode].Period)
  {
    digitalWrite(SIGNAL_PIN, HIGH); // начинаем новый импульс
    TimePeriod = CurrentTime; // отсечку периода приводим к текущему времени
    PulseFlag = false; // сбрасываем флаг текущего периода (в данном периоде импульс еще не завершали)
  }

  // проверка на окончание импульса
  if ((CurrentTime - TimePeriod > MT[in_mode].Duration) && !PulseFlag)
  {
    digitalWrite(SIGNAL_PIN, LOW); // заканчиваем текущий импульс
    PulseFlag = true; // ставим флаг, что импульс завершили в этом периоде
  }
}

// основной цикл
void loop()
{
  ////////////////////////////////////////////////////////////////////////////////
  // контроль кнопки
  ////////////////////////////////////////////////////////////////////////////////

  // проверка на нажатие с флагом для исключения повторной отработки
  if (digitalRead(BUTTON_PIN) == LOW && !ButtonFlag)
  {
    delay(LONG_BUTTON_TIME); // задержка для проверки долгого нажатия кнопки
    PulseFlag = false; //сбрасываем флаг сброса текущего импульса
    CurrentMode++; // переходим к следующему режиму
    ButtonFlag = true; // установка флага текущего нажатия кнопки
    // проверка долгого нажатия
    if (digitalRead(BUTTON_PIN) == LOW)
    {
      delay(BOUNCE_PROTECTION_TIME); // защита от дребезга кнопки
      CurrentMode = 0; // начинаем с первого режима
    }
    // проверка на достижение максимального режима
    if (CurrentMode > MaxMode)
    {
      CurrentMode = 0; // начинаем с первого режима
    }
  }
  // если кнопка была нажата, а сейчас отпущена - сбрасываем флаг
  if (ButtonFlag && digitalRead(BUTTON_PIN) == HIGH)
  {
    ButtonFlag = false;
  }

  ////////////////////////////////////////////////////////////////////////////////
  // исполнение функции для текущего режима
  ////////////////////////////////////////////////////////////////////////////////
  mode_control(CurrentMode);

}