UV матрица для засветки фоторезиста

Добрый День друзья платформы "Голос".

Предисловие

Цель проекта

Подготовка к сборке

Расчет резистора:
U₁ = 3*3.1 = 9.3 В, U₂ = 12 - 9.3 = 2.7 В,
R = 2.7/0.02 = 135 Ом, близкий к этому значение номинал это 150 Ом.
Расчет потребляемой мощности:
P_рез = U₂ * I = 0.054 Вт, P_общ = U_пр * I_пр + P_рез = 0.116 Вт,
P_пот = 99 * 0.116 = 11.484 Вт

Изготовление и сборка

Составление скетча

// Проект UV лампа
// Настройка пинов
int pinA = 2;                 // Пин прерывания
int pinB = 4;                 // Любой другой пин
int pinButton = 3;            // Пин кнопки

volatile int count = 0;       // Счетчик оборотов
int actualcount = 0;          // Временная переменная определяющая изменение основного счетчика

int numberclicking = 0;       // Переменная определяющая выбранный сегмент или счетчик нажатий

volatile int state = 0;       // Переменная хранящая статус вращения
volatile int clicking = 0;    // Переменная хранящая статус нажатия

volatile int pinAValue = 0;   // Переменные хранящие состояние пина, для экономии времени
volatile int pinBValue = 0;   // Переменные хранящие состояние пина, для экономии времени

volatile int pinButtonValue = 0;  // Переменные хранящие состояние пина кнопки
volatile long timeButtonDown = 0; // Переменная хранящая время нажатия кнопки
unsigned long timeButtonPressed = 1500; // Переменная хранящая предел времени долгго удержания кнопки
volatile bool isButtonDown = false; // Переменная хранящая флаг нажатия кнопки
volatile bool flagButtonLong = false; // Переменная хранящая флаг

unsigned long OldTime = 0; // Временнвая переменная для таймера

int anodPins[] = {A3, A2, A1, A4};                // Задаем пины для кажого разряда
int segmentsPins[] = {5, 6, 7, 8, 9, 10, 11, 12}; // Задаем пины для каждого сегмента (из 7 + 1(точка))

int numb[4] = {0, 0, 0, 0};   // Массив отправляемых чисел
int array[4] = {0, 0, 0, 0};  // Временный массив

int seg[10][8] =              // Массив сегментов {A, B, C, D, E, F, G, DP}
{
  {1, 1, 1, 0, 1, 0, 1, 1},   // Цифра 0
  {0, 1, 0, 0, 1, 0, 0, 0},   // Цифра 1
  {0, 1, 1, 1, 0, 0, 1, 1},   // Цифра 2
  {0, 1, 1, 1, 1, 0, 1, 0},   // Цифра 3
  {1, 1, 0, 1, 1, 0, 0, 0},   // Цифра 4
  {1, 0, 1, 1, 1, 0, 1, 0},   // Цифра 5
  {1, 0, 1, 1, 1, 0, 1, 1},   // Цифра 6
  {0, 1, 1, 0, 1, 0, 0, 0},   // Цифра 7
  {1, 1, 1, 1, 1, 0, 1, 1},   // Цифра 8
  {1, 1, 1, 1, 1, 0, 1, 0}    // Цифра 9
};

int segdone[4][8] =
{
  {0, 1, 0, 1, 1, 0, 1, 1},   // Буква d
  {0, 0, 0, 1, 1, 0, 1, 1},   // Буква о
  {0, 0, 0, 1, 1, 0, 0, 1},   // Буква n
  {1, 0, 1, 1, 0, 0, 1, 1},   // Буква E
};

void setup()
{
  pinMode(13, OUTPUT);
  pinMode(pinA, INPUT);          // Пины в режим приема INPUT
  pinMode(pinB, INPUT);
  pinMode(pinButton, INPUT);
  
  for (int i = 0; i < 4; i++)    // Аноды в режите вывода
  {
    pinMode(anodPins[i], OUTPUT);
  }
  for (int j = 0; j < 8; j++)    // Сегменты в режиме вывода
  {
    pinMode(segmentsPins[j], OUTPUT);
  }
  
  attachInterrupt(0, A, CHANGE);      // Настраиваем обработчик прерываний по изменению сигнала на линии А
  attachInterrupt(1, Button, CHANGE); // Настраиваем обработчик прерываний по изменению сигнала на кнопке

  // Serial.begin(9600); // Включаем Serial
}

void loop()
{
  if (actualcount != count)       // Чтобы не загружать ненужным выводом в Serial, выводим состояние
  {                               // счетчика только в момент изменения
    actualcount = count;
    // Serial.println(actualcount);
  }

  if (clicking == 1)              // Если кнопка была нажата
  {
    numberclicking ++;            // Увеличивает счетчик нажаний
    clicking = 0;
    if (numberclicking == 4) numberclicking = 0; // Ограничиваем счетчик нажатий по количеству разрядов индикатора
    // Serial.println(numberclicking);
  }
  
  Filling(); // Заполняем массив отправляемых чисел
  
  Sending(); // Отправляем массив в индикатор

  Start();   // Ожидаем долгого нажатия
}

void A()                                    // Функция вызываемая прерыванием линией А
{
  pinAValue = digitalRead(pinA);            // Получаем состояние пинов A и B
  pinBValue = digitalRead(pinB);

  cli();                                    // Запрещаем обработку прерываний
  if (!pinAValue &&  pinBValue) state = 1;  // Если при спаде линии А на линии B лог. единица, то вращение в одну сторону
  if (!pinAValue && !pinBValue) state = -1; // Если при спаде линии А на линии B лог. ноль, то вращение в другую сторону
  if (pinAValue && state != 0)
  {
    if (state == 1 && !pinBValue || state == -1 && pinBValue) // Если на линии А снова единица, фиксируем шаг
    {
      count += state;
      state = 0;
    }
  }
  sei(); // Разрешаем обработку прерываний
}

void Button()                              // Функция вызываемая прерыванием кнопкой
{
  if (millis() - timeButtonDown < 50) return; // Если время с предыдущего нажатия меньше 50 мс возвращаемся
  pinButtonValue = digitalRead(pinButton); // Получаем состояние кнопки
  
  cli();                                   // Запрещаем обработку прерываний
  timeButtonDown = millis();               // Запоминаем время нажатия
  if (!pinButtonValue)                     // Если есть инверсный сигнал
  {
    isButtonDown = true;                   // Устанавливаем флаг нажатия кнопки (для алгоритла долгого нажатия кнопки)
  }
  else if (isButtonDown)
  {
    clicking = 1;                          // Меняем статус срабатывания
    isButtonDown = false;
  }
  sei();                                   // Разрешаем обработку прерываний
}

void Filling()                          // Функция заполнения массива
{
  for (int m = 1; m < 4; m = m + 2)     // Заполнение второго и четвертого сегмента
  {
    if (numberclicking == m)            // Если нажали кнопку первый или третий раз...
    {                                   // переход от первого сегмента ко второму или от третьего к четвертому
      if (actualcount == 10) count = 0; // Ограничиваем максимум до девяти
      if (actualcount == -1) count = 9; // Ограничиваем минимум до нуля
      numb[m] = actualcount;            // Вписываем значение счетчика в массив
    }
  }                                     // numb[4] = {0, actualcount, 0, actualcount};
  
  for (int l = 0; l < 3; l = l + 2)     // Заполнение первого и третьего сегмента
  {
    if (numberclicking == l)            // Если кнопку не нажимали или нажали второй раз (не нажимали numberclicking = 0)
    {                                   // начало на первом сегменте или переход от второго к третьему сегменту
      if (actualcount > 6) count = 0;   // Ограничиваем максимум до шести
      if (actualcount == -1) count = 6; // Ограничиваем минимум до нуля
      numb[l] = actualcount;            // Вписываем значение счетчика в массив
    }
  }                                     // numb[4] = {actualcount, 0, actualcount, 0};
}

void Sending()                          // Функция отправки значений массива в индикатор
{
  for (int o = 0; o < 4; o++)           // Каждый разряд по очереди
  {
    for (int k = 0; k < 8; k++)         // Каждый сегмент по очереди - исходя из заданного состояния счетчика
    {
      digitalWrite(segmentsPins[k], ((seg[numb[o]][k] == 1) ? LOW : HIGH)); // Тернарный оператор при условии равенства
                                                                            // условия выполняется LOW иначе HIGH
    }
    digitalWrite(anodPins[o], HIGH);    // Включить сегмент
    delay(1);                           // Выждать для восприятия
    digitalWrite(anodPins[o], LOW);     // Отключить сегмент
  }
}

void Start() // Функция определения долгого нажатия
{
  if (millis() - timeButtonDown > timeButtonPressed && isButtonDown) // Если пришло время больше timeButtonPressed с момента нажатия...
  {
    flagButtonLong = true; // Установить флаг
    // Serial.println("flagButtonLong");
  }
  if (flagButtonLong && isButtonDown)
  {
    if (!digitalRead(pinButton) && millis() - timeButtonDown > timeButtonPressed) // Если по истечению времени больше timeButtonPressed кнопка нажата...
    {
      // Serial.println("Long_Press");
      Ex(); // Есть долгое нажатие запустить отсчет времени
    }
    isButtonDown = false; // Сбрасываем флаги
    flagButtonLong = false;
  }
}

void Ex() // Функция отсчета массива numb и отправки значений в индикатор 
{
  digitalWrite(13, HIGH);
  // Serial.println("Start");
  int sec = (60 * ((numb[0] * 10) + numb[1])) + (numb[2] * 10) + numb[3]; // Перевод массива в количество секунд
  for (int s = sec; s > 0; --s)         // Каждую секунду
  {
    OldTime = millis();                 // Переменная для таймера
    while ((millis() - OldTime) < 1000) // В течении секунды...
    {                                   // ... пересчитать в зависимости от уменьшения количества секунд s массив array
      array[0] = s / 600;               // Десятки минут
      array[1] = (s / 60) % 10;         // Минуты
      array[2] = (s % 60) / 10;         // Десятки секунд
      array[3] = (s % 60) % 10;         // Секунды
      /* for (int p = 0; p <= 3; p++)
      {
        Serial.print(array[p]);
      }
      Serial.println();*/
      for (int d = 0; d < 4; d++)       // Каждый разряд по очереди
      {
        for (int w = 0; w < 8; w++)     // Каждый сегмент по очереди - исходя из заданного состояния счетчика
        {
          digitalWrite(segmentsPins[w], ((seg[array[d]][w] == 1) ? LOW : HIGH)); // Тернарный оператор при условии равенства
                                                                                 // условия выполняется LOW иначе HIGH
        }
      digitalWrite(anodPins[d], HIGH);  // Включить сегмент
      delay(1);                         // Выждать для восприятия
      digitalWrite(anodPins[d], LOW);   // Отключить сегмент
      }
    }
  }
  digitalWrite(13, LOW);
  OldTime = millis();
  while ((millis() - OldTime) < 3000)   // В течении заданного времени пишем "donE" в индикатор
  {
    Done();
  }
  count = 0;                   // Обнуляем счетчик
  for (int b = 0; b <= 3; b++) // Обнуляем массив numb для следующего цикла
  {
    numb[b] = 0;
  }
  // Serial.println("Done");
}

void Done() // Функция отправки слова "donE" в индикатор
{
  for (int g = 0; g < 4; g++)       // Каждый разряд по очереди
  {
    for (int f = 0; f < 8; f++)     // Каждый сегмент по очереди - исходя из заданного состояния счетчика
    {
      digitalWrite(segmentsPins[f], ((segdone[g][f] == 1) ? LOW : HIGH)); // Тернарный оператор при условии равенства
                                                                          // условия выполняется LOW иначе HIGH
    }
    digitalWrite(anodPins[g], HIGH);  // Включить сегмент
    delay(1);                         // Выждать для восприятия
    digitalWrite(anodPins[g], LOW);   // Отключить сегмент
  }
}

Итог

Комплектация

Спасибо за внимание.