Централизованный пульт контроля источников освещения ЦПКИО-2Д Ротор

Для этого необходимо, во-первых, добавить в среду Arduino описание контроллера. Для этого идем на официальный сайт Arduino и скачиваем оттуда подходящий для установленной у вас версии среды архив описаний (для 1.6, для 1.5, для 1.0).

Содержимое архива следует извлечь в папку hardware папки среды Arduino. В дальнейшем я описываю происходящее на примере среды 1.0.3, которой пока пользуюсь.

Когда описания скопированы, следует запустить Arduino и загрузить скетч программатора в Arduino, которая будет использоваться в качестве этого самого программатора. Скетч находится в меню Файл — Примеры — ArduinoISP.

Разумеется, следует выбрать свою плату и порт. Я выбираю Mega, потому что у меня она и есть:

После загрузки скетча программатора необходимо переключиться на целевую плату. Т.е. в нашем случае — ATmega328 с частотой 8 МГц и внутренним задающим генератором. Она будет в списке плат, если описания, о которых говорил выше, скопированы правильно:

Теперь нужно соединить линии MISO, MOSI и SCK платы-программатора и платы с будущей Arduino, а также подключить RESET, GND и VCC. Плюс питания лучше именно в последнюю очередь.

Исходя из приведенной выше инфографики и описания Arduino Mega, вырисовывается следующая картина:

SPI — Arduino Mega — ATmega328p

MISO — 50 — 16
MOSI — 51 — 15
SCK — 52 — 17
SS (RESET) — 53 — 29

Физическое подключение на ваш вкус, я применил исключительно варварский метод — обычные макетные провода прямо в отверстия платы, без пайки и изоляции:

Если все готово — записываем загрузчик. Сначала убеждаемся, что выбран правильный программатор (Сервис — Программатор — Arduino as ISP):

Потом делаем Сервис — Записать загрузчик:

В коде нужно задать команды на включение и выключение своих периферийных устройств. Опционально — поменять таймаут автовыключения.

Это все располагается в секции переменных.

// Код сна: http://donalmorrissey.blogspot.ru/2010/04/sleeping-arduino-part-5-wake-up-via.html
// Библиотека Livolo: http://forum.arduino.cc/index.php?action=dlattach;topic=153525.0;attach=108106


#include <avr/sleep.h>
#include <avr/power.h>
#include <livolo.h>

#define adc_disable() (ADCSRA &= ~(1<<ADEN)) // disable ADC (before power-off) 
#define adc_enable() (ADCSRA |= (1<<ADEN)) // re-enable ADC


#define  txPin  7 //  пин передатчика
Livolo livolo(txPin);

#define PULSESHORT 450  
#define PULSELONG  1350
#define PULSESYNC  13950
#define encA 5
#define encB 6 // пины энкодера
#define buttonPin 2 // пин кнопки (прерывание)
#define roomLed 10 // пин индикатора комнаты
#define kitchenLed 9 // пин индикатора кухни
#define switchLed 3 // пин индикатора переключения освещения
#define switchLedTimeOut 150 // время свечения индикатора переключения освещения
#define switchTreshold 4 // количество срабатываний энкодера до переключения
#define offDelay 15000 // таймаут автовыключения
#define rLev 3 // количество уровней света комнаты
#define kLev 3 // количество уровней света кухни
#define glev 2 // количество уровней света всего
#define txPowerPin 8 // пин питания передатчика


#define kitchenBackLightOn1 12
#define kitchenBackLightOn2 34
#define kitchenMainLightOn 56

#define roomBackLightOn 12
#define roomMainLightOn1 34
#define roomMainLightOn2 56

#define mainLightOn 12


#define kitchenBackLightOff1 12
#define kitchenBackLightOff2 34
#define kitchenMainLightOff 56

#define roomBackLightOff 12
#define roomMainLighOtff1 34
#define roomMainLightOff2 56

#define mainLightOff 12

#define LivoloID 8500

volatile byte rotorMode = 0; // режим работы
byte currentMode = 0; // текущий режим работы
int curEncA, prevEncA, curButton, prevButton; // текущее значение энкодера, предыдущее
byte encCountPlus = 0; // счетчик энкодера
byte encCountMinus = 0; // счетчик энкодера
unsigned long offTimeOut = 0; // счетчик таймера автовыключения
unsigned long modeTimeOut = 0; // счетчик таймера короткого нажатия для переключения режима
unsigned long switchLedTime = 0; // счетчик выключения индикатора переключения освещения
unsigned long modeTime = 0; // длительность нажатия
unsigned int modeTreshold = 500; // пороговая длительность короткого нажатия (короче ххх мс)
unsigned int bounceTreshold = 200; // пороговая длительность дребезга контактов
byte rLevState = 0;
byte kLevState = 0;
byte gLevState = 0;
// флаги света k - кухня, r - комната, h - коридор, b - ванная
boolean kBackState = false;
boolean kBackState1 = false;
boolean kMainState = false;
boolean rBackState = false;
boolean rMainState = false;
boolean rMainState1 = false;
boolean hMainState = false;
boolean bMainState = false;
boolean afterSleep = false; // флаг выхода из режима сна
boolean modeTimeOutStart = false;
boolean switchLedOn = false;
boolean allOn = false; // флаг "все включено" для индикатора переключения
boolean allOff = false; // флаг "все выключено" для индикатора переключения


static void ookPulse(int on, int off) {
  digitalWrite(txPin, HIGH);
  delayMicroseconds(on);
  digitalWrite(txPin, LOW);
  delayMicroseconds(off);
}


static void rcSend(long remoteCode) {
  
 for (byte reSend = 0; reSend < 8; reSend++) {
  for(byte repeat=0; repeat<4; repeat++){

   for (byte i = 24; i>0; i--) { // transmit remoteID
    byte txPulse=bitRead(remoteCode, i-1); // read bits from remote ID
     // Serial.print(txPulse);
      switch (txPulse) {
    
        case 0:  // 00
          ookPulse(PULSESHORT,PULSELONG);
          //ookPulse(PULSESHORT,PULSELONG);
          break;
      
        case 1:  // 11
          ookPulse(PULSELONG,PULSESHORT);
          //ookPulse(PULSELONG,PULSESHORT);
          break;
      } // switch
    } // for loop
    ookPulse(PULSESHORT,PULSESYNC); // S(ync)
  //  Serial.println();
  } // repeat
 }
delay(150);
}

void switchLedToggle() {
  digitalWrite(switchLed, HIGH);
  switchLedTime = millis();
  switchLedOn = true;
}

void lightsUp(boolean lightsUpMode) {

// чтобы при включении после сна при "выключении" свет выключался с максимума
// а при "включении" - с минимума
  if (afterSleep == true) {
    if (lightsUpMode == false) {
      gLevState = 1;
      rLevState = 3;
      kLevState = 3;
    } else 
           {gLevState = 0;
            rLevState = 0;
            kLevState = 0;
           }
  afterSleep = false; // сброс признака "после сна"
  }
  
// Все освещение
  if (rotorMode == 2) {
   if (lightsUpMode == false){
    if (allOff == false) {
     switchLedToggle();
     if (digitalRead(buttonPin) == HIGH) {    
      // выключить все
      gLevState = 0;
      rLevState = 0;
      kLevState = 0;
      
      rcSend(kitchenBackLightOff1);
      rcSend(kitchenBackLightOff2);
      rcSend(roomBackLightOff);
      livolo.sendButton(LivoloID, mainLightOff);      
      
    }
   allOff = true;
   allOn = false;
   }
  }

    if (lightsUpMode == true){
      // включить все, что не включено
    if (allOn == false) {
     switchLedToggle();
     if (digitalRead(buttonPin) == HIGH) {
      gLevState = 1;
      rLevState = 3;
      kLevState = 3;
      
      rcSend(kitchenBackLightOn1);
      rcSend(kitchenBackLightOn2);
      rcSend(roomBackLightOn);
      
      livolo.sendButton(LivoloID, mainLightOff);      // сначала выключим все Livolo
      livolo.sendButton(LivoloID, kitchenMainLightOn); //#1 теперь включим
      livolo.sendButton(LivoloID, roomMainLightOn1);  // #2  
      livolo.sendButton(LivoloID, roomMainLightOn2); // #3     
      livolo.sendButton(LivoloID, mainLightOn); // #6
   
      }
      allOn = true;
      allOff = false;
     }
    }
   }

// Кухня
  if (rotorMode == 1) {

    if (lightsUpMode == false && kLevState > 0) {
      switchLedToggle();
     if (digitalRead(buttonPin) == HIGH) {
      if (kLevState == 3) {
        // выкл верх
       livolo.sendButton(LivoloID, kitchenMainLightOff); // #3     
      }

      if (kLevState == 2) {
        // выкл фон 2
      livolo.sendButton(LivoloID, kitchenBackLightOff2); // #6        
      }      

      if (kLevState == 1) {
        // выкл фон 1
      rcSend(kitchenBackLightOff1);
      
      }    
     }
      
      if (kLevState!=0) {
      kLevState--;}
       //   Serial.println(kLevState);
   }

    if (lightsUpMode == true && kLevState < 3) {
      switchLedToggle();
      kLevState++;
      if (digitalRead(buttonPin) == HIGH) {
      if (kLevState > 3) {kLevState = 3;}
       //  Serial.println(kLevState);
     
      if (kLevState == 1) {
        // вкл фон 1
      
      rcSend(kitchenBackLightOn1);

      }

      if (kLevState == 2) {
        // вкл фон 2
      livolo.sendButton(LivoloID, kitchenBackLightOn2); // #6
      }      

      if (kLevState == 3) {
        // вкл верх
      livolo.sendButton(LivoloID, kitchenMainLightOn); // #3     
      }    
     }
    }
  
  }

// Комната
  if (rotorMode == 0) {
   if (lightsUpMode == false && rLevState > 0) {
    switchLedToggle();
    if (digitalRead(buttonPin) == HIGH) {      
      if (rLevState == 3) {
        // выкл верх1
      livolo.sendButton(LivoloID, roomMainLighOtff1); //#1
      }

      if (rLevState == 2) {
        // выкл верх
      livolo.sendButton(LivoloID, roomMainLightOff2);  // #2  
      }      

      if (rLevState == 1) {
        // выкл фон
      rcSend(roomBackLightOff);
      }    
    }
      if (rLevState != 0) {
      rLevState--;
      }
    }

    if (lightsUpMode == true && rLevState < 3) {
     switchLedToggle();
     rLevState++;
     if (digitalRead(buttonPin) == HIGH) {      
      if (rLevState == 1) {
        // вкл фон
      rcSend(roomBackLightOn);
      }

      if (rLevState == 2) {
        // вкл верх
      livolo.sendButton(LivoloID, roomMainLightOn1); //#1
      }      

      if (rLevState == 3) {
        // вкл верх 1
      livolo.sendButton(LivoloID, roomMainLightOn2);  // #2  
      }    
     }
    }
  
  }  
  
}

void wakeUp() {
  detachInterrupt(0);
}

void setMode() {

  if (rotorMode >= 2 ) {
     rotorMode = 0;
  } else {
    rotorMode++;
  }

 offTimeOut = millis();

}





void ledBlink() {
 
  for (byte iLed = 0; iLed<3; iLed++) {
    digitalWrite(kitchenLed, HIGH);
    digitalWrite(roomLed, HIGH);
    delay(100);
    digitalWrite(kitchenLed, LOW);
    digitalWrite(roomLed, LOW);
    delay(100);    
 }

 
}

void setLed() {
 
   if (rotorMode == 0) { // Комната
    digitalWrite(roomLed, HIGH);
    digitalWrite(kitchenLed, LOW);
  }

  if (rotorMode == 1) { // Кухня
    digitalWrite(roomLed, LOW);
    digitalWrite(kitchenLed, HIGH);
  }

  if (rotorMode == 2) { // Комната и кухня
    digitalWrite(roomLed, HIGH);
    digitalWrite(kitchenLed, HIGH);
  } 
  
}



void enterSleep()
{
// ledBlink();
 afterSleep = true;
 digitalWrite(txPin, LOW); 
 digitalWrite(txPowerPin, LOW);
 digitalWrite(roomLed, LOW);
 digitalWrite(kitchenLed, LOW); 
 digitalWrite(switchLed, LOW); 
 pinMode(txPin, INPUT);
 pinMode(txPowerPin, INPUT);
 pinMode(roomLed, INPUT);
 pinMode(kitchenLed, INPUT); 
 pinMode(switchLed, INPUT); 

 attachInterrupt(0, wakeUp, LOW);

  adc_disable();

  set_sleep_mode(SLEEP_MODE_PWR_DOWN);
  
  sleep_enable();
  
  sleep_mode();
  
 sleep_disable();
 power_all_enable();
 
 pinMode(txPin, OUTPUT);
 pinMode(txPowerPin, OUTPUT);
 pinMode(roomLed, OUTPUT);
 pinMode(kitchenLed, OUTPUT); 
 pinMode(switchLed, OUTPUT); 
 digitalWrite(txPin, LOW); 
 digitalWrite(txPowerPin, HIGH);
 
// ledBlink();
 setLed();
 offTimeOut = millis();
 allOn = false;
 allOff = false;

}

void setup() {
 // Serial.begin(115200);
 pinMode(txPin, OUTPUT);
 pinMode(txPowerPin, OUTPUT);
 pinMode(roomLed, OUTPUT);
 pinMode(kitchenLed, OUTPUT); 
 pinMode(switchLed, OUTPUT); 
 digitalWrite(txPin, LOW); 
 digitalWrite(txPowerPin, HIGH);
 digitalWrite(roomLed, LOW); 
 digitalWrite(kitchenLed, LOW);
 digitalWrite(switchLed, LOW);
//  pinMode(buttonPin, INPUT_PULLUP);
 pinMode(buttonPin, INPUT);
 pinMode(encA, INPUT);
 pinMode(encB, INPUT);
 prevEncA = digitalRead(encA);
 offTimeOut = millis();
 rotorMode = 0;
 setLed();
 prevButton = digitalRead(buttonPin);
}



void loop() {

if ((millis() - offTimeOut) > offDelay) {
     enterSleep();

 } else {  
 
 // выключение индикации переключения режимов  
 if (switchLedOn == true) {
   if ((millis() - switchLedTime) > switchLedTimeOut) {
     digitalWrite(switchLed, LOW);
     switchLedOn = false;
   }
 }

// сброс таймера автовыключения при нажатом энкодере
if (digitalRead(buttonPin) == LOW) {
  offTimeOut = millis();
}

// переключение режимов
curButton = digitalRead(buttonPin);
  if ((prevButton == HIGH) && (curButton == LOW)) {
    if (modeTimeOutStart == false) {
      modeTimeOut = millis();
      modeTimeOutStart = true;
    }
  } else {
        if (modeTimeOutStart == true) {
          modeTime = millis() - modeTimeOut;
          if ((modeTime < modeTreshold) && (modeTime > bounceTreshold)) {
            setMode();
            modeTimeOutStart = false;
            prevButton = digitalRead(buttonPin);
          } else {
              modeTimeOutStart = false;
              prevButton = digitalRead(buttonPin);
          }
        }
  }
   
// переключение индикации режимов 
if (currentMode != rotorMode) { // если текущий режим не совпадает с установленным, то устанавливаем текущий режим
  currentMode = rotorMode;

// и включаем соответствующую индикацию

  setLed();  
}

// подсчет импульсов
 curEncA = digitalRead(encA);
   if ((prevEncA == LOW) && (curEncA == HIGH)) {
     offTimeOut = millis();
     if (digitalRead(encB) == LOW) {
       encCountMinus++;
       encCountPlus = 0;
      // Serial.println("Encoder Minus");

       if (encCountMinus > switchTreshold) {
          encCountMinus = 0;
          lightsUp(false);
        }

     } else {
       encCountPlus++;
       encCountMinus = 0;
      // Serial.println("Encoder Plus");       

       if (encCountPlus > switchTreshold) {
          encCountPlus = 0;
          lightsUp(true);
        }
     }
   } 
   prevEncA = curEncA;
 }
}