КайтВлад

// Pekavet v10

#include <Servo.h>
//----   
int TimeDelayStart  = 600;                 // время задержки старта в секундах    
int TimeDelayStart2  = 1200;                 // время задержки старта в секундах        
int TimeDelay;
int Cycle           = 3;                   // количество полных циклов
int cycleStep;
//----
Servo servosm;                             // создаём объект для контроля сервы затвора
int ZatvStep        = 20;                  // задержка между срабатываниями сервы затвора в шагах двигателя
int zatv;
unsigned long time;                        // переменная отсчитавающая время
int servosm_pin     = 6;                   // пин для сервы затвора

Servo servobig;                            // создаём объект для контроля сервы вертикального поворота
// 809, 2180
int min_servo       = 1200;
int max_servo       = 2180;
boolean servobig_go = false;   
int servobig_pos;
int servobig_pin    = 5;                   // пин для сервы вертекального поворота камеры
//----
int LevelStep       = 5;                   // количество круговых уровней сделанных платформой
int levelval;                    // переменная для хранения количиства уровней
//----
int moto_pin        = 11;                  // пин для управления двигателем горизонтального разворота камеры
int motoIN2_pin     = 8;                   // пин для драйвера IN2 двигателем горизонтального разворота камеры
int motoIN1_pin     = 7;                   // пин для драйвера IN1 двигателем горизонтального разворота камеры
int motostep;                    // шаги двигателя
boolean moto_go = false;     
//----   
int btnval;                    // переменная состояния концевика
int btn_pin         = 12;                  // пин для концевика   

boolean btn_block = false;                 // контроль концевика от удержания
boolean foto_go = false;
int kadr;

//----   
boolean led_block = false;

int Status;
int A,A_1,A_2,B,B_1,B_2,C,C_1,C_2,D,D_1,D_2;
//+------------------------------------------------------------------+
//|                    |
//+------------------------------------------------------------------+
void setup()   
{   
    //----
    pinMode(13, OUTPUT);                    // назначение выхода 13-му пину для светодиода
    attachInterrupt(0, Reset, RISING);                    // привязываем 0-е прерывание к функции Reset().
    //----
    pinMode(motoIN2_pin, OUTPUT);                         // назначение выход 8-му пину для IN2 драйвера двигателя
    pinMode(motoIN1_pin, OUTPUT);                         // назначение выход 7-му пину для IN1 драйвера двигателя
    digitalWrite(motoIN2_pin, LOW);                       // назначение направление движения
    digitalWrite(motoIN1_pin, HIGH);                      // для двигателя
    analogWrite(moto_pin,0);
    //----
    pinMode(btn_pin, INPUT);                    // назначение входа для концевика
    servobig.attach(servobig_pin, min_servo, max_servo);  // подключаем серву вертикального поворота
    servosm.attach(servosm_pin);                          // подключаем серву кнопки затвора
    //----       
    Serial.begin(9600);                    // инициализация работы с COM-портом
}   
//+------------------------------------------------------------------+
//|                    |
//+------------------------------------------------------------------+
void loop()   
{    
    //----
    switch (Status)   
    {
      //----///////////////////// 0 цикл ожидания /////////////////////   
    case 0:   // ожидание
      if(led_block==false)
      {
        Blink(0);
        led_block=true;
      }
      //----   
      ServoBig (2000);
      kadr++;
      if(kadr>=60)
      {
        kadr=0;
        ServoSmall();
      }
      delay(1000);   
      break;

      //----///////////////////// кнопка А панорама /////////////////////   
    case 1:    // панорама
      if(led_block==false)
      {
        Blink(1);
        led_block=true;
      }
      //----                    // запуск двигателя
      Moto ();
      //----
      btnval = digitalRead(btn_pin);                    // узнаём состояние концевика
      if(btnval==HIGH && btn_block==false)                    // если концевик зажат и не стоит блокировка
      {
        if(levelval==LevelStep)
        {   
          foto_go=false;                    // запрещаем делать съёмку
          led_block=false;
          Status= 0;
        }
        if(levelval<LevelStep)
        {   
          analogWrite(moto_pin,0);

          levelval++;
          ServoBig (min_servo + ((max_servo-min_servo)/(LevelStep-1))*(levelval-1));    // выставление вертикальной сервы на угол согластно уровня   
          ServoSmall();                    // делаем снимок   
          foto_go=true;                    // разрешаем делать съёмку
        }
        btn_block=true;                    // ставим блокировку от зажима концевика
      }
      if(btnval==LOW)                    // если концевик отпущен
      {
        btn_block=false;                    // снимаем блокировку
      }
      //----   
      if(foto_go==true)
      {
        motostep++;
        if(levelval==1 || levelval==LevelStep)
        {
          zatv=ZatvStep*2;
        }
        if(levelval>1 && levelval<LevelStep)
        {
          zatv=ZatvStep;
        }

        if(motostep >= zatv)                    // если наступил момент для срабатывания сервы для затвора
        {
          ServoSmall();                    // делаем снимок
          motostep=0;
        }
      }
      break;

      //----///////////////////// кнопка В панорама 2(задержка)  /////////////////////   
    case 2:    // панорама
      //----   
      if(cycleStep > Cycle-1)    
      {
        led_block=false;
        Status= 0;
        return;
      }
      //----   
      if(led_block==false)
      {
        Blink(2);
        led_block=true;
      }
      //----
      PanoCycle();
      //----
      break;

      //----///////////////////// кнопка C панорама 3(задержка)  /////////////////////   
    case 3:     // панорама
      //----   
      if(cycleStep > Cycle-1)    
      {
        led_block=false;
        Status= 0;
        return;
      }
      //----   
      if(led_block==false)
      {
        Blink(3);
        led_block=true;
      }
      //----   
      PanoCycle();
      //----
      break;

      //----/////////////////////  /////////////////////   
    case 4:      
      if(led_block==false)
      {
        Blink(4);
        led_block=true;

        ServoSmall();   
      }
      break;

      //----/////////////////////  /////////////////////   
    default:        
      break;
      //----
    }

}
//+------------------------------------------------------------------+
//|                    |
//+------------------------------------------------------------------+
void Moto()
{
    int dpos;
    for(dpos=0; dpos<255; dpos+=5)
    {
      analogWrite(moto_pin,dpos);
    }
    delay(10);
    for(dpos=255; dpos>0; dpos-=5)
    {
      analogWrite(moto_pin,dpos);
    }
    delay(10);
}

//+------------------------------------------------------------------+
//|                    |
//+------------------------------------------------------------------+
void ServoBig (int posAngle)                       // функция поворота вертикальной сервы
{
    int pos = servobig.readMicroseconds();           // определение положения сервы вертикального наклона
    while(pos > posAngle)
    {
      pos--;
      delay(5);
      servobig.writeMicroseconds(pos);
    }
    while(pos < posAngle)
    {
      pos++;
      delay(5);
      servobig.writeMicroseconds(pos);
    }
}
//+------------------------------------------------------------------+
//|                    |
//+------------------------------------------------------------------+
void ServoSmall()                    // функция поворота сервы затвора
{    
    int val = analogRead(4); //аналоговый пин 4
    val = val*2+500;   
    int prevval = val/5;
    int pos;
    //----
    delay(prevval);
    for(pos = 580; pos <= 665; pos +=5)              // делаем нажим на кнопку затвора
    {                    // здесь нужно проработать код   
      servosm.writeMicroseconds(pos);                // для подстройки к параметрам фотоаппарата   
      delay(5);
    }
    delay(val);
    //----
    for(pos = 665; pos >= 580; pos -=5)              // делаем нажим на кнопку затвора
    {                    // здесь нужно проработать код   
      servosm.writeMicroseconds(pos);                // для подстройки к параметрам фотоаппарата   
      delay(5);
    }
}

//+------------------------------------------------------------------+
//|                    |
//+------------------------------------------------------------------+
void Reset()
{
    led_block=false;
    levelval=0;
    foto_go=false;

    // кнопка A
    A=analogRead(3);
    if(A>500)A_1=HIGH;
    else A_1=LOW;
    if(A_2!=A_1)
    {
      if (moto_go == true) moto_go = false;
      A_2=A_1;
      Status=1;
    }

    // кнопка B   
    B=analogRead(2);
    if(B>500)B_1=HIGH;
    else B_1=LOW;
    if(B_2!=B_1)
    {
      if (moto_go == true) moto_go = false;
      B_2=B_1;
      TimeDelay = TimeDelayStart;
      cycleStep = 0;
      Status=2;
    }

    // кнопка C поворот платформы
    C=analogRead(1);
    if(C>500)C_1=HIGH;
    else C_1=LOW;
    if(C_2!=C_1)
    {
      if (moto_go == true) moto_go = false;
      C_2=C_1;
      TimeDelay = TimeDelayStart2;
      cycleStep = 0;
      Status=3;
    }

    // кнопка D затвор
    D=analogRead(0);
    if(D>500)D_1=HIGH;
    else D_1=LOW;
    if(D_2!=D_1)
    {
      if (moto_go == true) moto_go = false;
      D_2=D_1;
      Status=4;
    }
}

//+------------------------------------------------------------------+
//|                    |
//+------------------------------------------------------------------+
void Blink(int i)
{
    if(i==0)
    {
      for(int pos1=10; pos1>0;pos1--)
      {
        digitalWrite(13, HIGH);
        delay(100);
        digitalWrite(13, LOW);
        delay(100);
      }   
      return;   
    }
    for(int pos1=i; pos1>0;pos1--)
    {
      digitalWrite(13, HIGH);
      delay(200);
      digitalWrite(13, LOW);
      delay(200);
    }
}

//+------------------------------------------------------------------+
//|                    |
//+------------------------------------------------------------------+
void PanoCycle()
{
    //----   
    while(TimeDelay > 0)
    {
      TimeDelay--;
      ServoBig (2000);
      kadr++;
      if(kadr>=60)
      {
        kadr=0;
        ServoSmall();
      }
      delay(1000);   
    }
    //----                    // запуск двигателя
    Moto ();
    //----
    btnval = digitalRead(btn_pin);                    // узнаём состояние концевика
    if(btnval==HIGH && btn_block==false)                    // если концевик зажат и не стоит блокировка
    {
      if(levelval==LevelStep)
      {   
        cycleStep++;
        levelval=0;   
      }
      if(levelval<LevelStep)
      {   
        analogWrite(moto_pin,0);
        levelval++;
        ServoBig (min_servo + ((max_servo-min_servo)/(LevelStep-1))*(levelval-1));    // выставление вертикальной сервы на угол согластно уровня   
        ServoSmall();                    // делаем снимок   
        foto_go=true;                    // разрешаем делать съёмку
      }
      btn_block=true;                    // ставим блокировку от зажима концевика
    }
    if(btnval==LOW)                    // если концевик отпущен
    {
      btn_block=false;                    // снимаем блокировку
    }
    //----   
    if(foto_go==true)
    {
      motostep++;
      if(levelval==1 || levelval==LevelStep)
      {
        zatv=ZatvStep*2;
      }
      if(levelval>1 && levelval<LevelStep)
      {
        zatv=ZatvStep;
      }

      if(motostep >= zatv)                    // если наступил момент для срабатывания сервы для затвора
      {
        ServoSmall();                    // делаем снимок
        motostep=0;
      }
    }    
}

void ServoSmall()                    // функция поворота сервы затвора
{    
    int val = analogRead(4);                       //аналоговый пин 4 (считываем значение потенциометра)
    val = val*2+500;                    // рассчитываем задержки
    int prevval = val/5;
    int pos;
    //----
    delay(prevval);                    // задержка перед спуском кнопки затвора
    for(pos = 580; pos <= 665; pos +=5)              // делаем нажим на кнопку затвора
    {                    // здесь нужно проработать код   
      servosm.writeMicroseconds(pos);                // для подстройки к параметрам фотоаппарата   
      delay(5);
    }
    delay(val);                    // задержка на удержание кнопки затвора
    //----
    for(pos = 665; pos >= 580; pos -=5)              // делаем нажим на кнопку затвора
    {                    // здесь нужно проработать код   
      servosm.writeMicroseconds(pos);                // для подстройки к параметрам фотоаппарата   
      delay(5);
    }
}

#include <multiCameraIrControl.h>

Sony A900(9);

void setup(){
}

void loop(){
   A900.shutterNow();                   //мгновенная съёмка  
   delay(5000);
   A900.shutterDelayed();            // съёмка с задержкой для коррекции авто настроек
   delay(5000);
}