КайтВлад

#include <Servo.h>                
#include <multiCameraIrControl.h>

///////////////////////////////////////////////////////////////////
// Номера входов и выходов
///////////////////////////////////////////////////////////////////

int servo_gor_pin    = 7;                   // пин для сервы горизонтального поворота камеры
int servo_vert_pin   = 6;                   // пин для сервы вертикального поворота камеры

int manual_pin       = 10;                   // пин включающий ручное управление с пульта
int manual_gor_pin   = 12;                   // вход сигнала с приёмника для горизонтальной сервы
int manual_vert_pin  = 11;                  // вход сигнала с приёмника для вертикальной сервы

///////////////////////////////////////////////////////////////////
// Объекты программы
///////////////////////////////////////////////////////////////////

Servo servo_gor;                            // создаём объект для контроля сервы горизонтального поворота
Servo servo_vert;
Sony nex(9);

///////////////////////////////////////////////////////////////////
// Переменные программы
///////////////////////////////////////////////////////////////////

boolean servo_gor_go = LOW;
int posv1 = 70;
int posv2 = 100;
int posv3 = 50;
int posr = 92;

///////////////////////////////////////////////////////////////////
// Инициализация
///////////////////////////////////////////////////////////////////

void setup()   
{   
    pinMode(servo_vert_pin, OUTPUT);
    pinMode(servo_gor_pin, OUTPUT);
    pinMode(manual_vert_pin, INPUT);
    pinMode(manual_gor_pin, INPUT);
    pinMode(manual_pin, INPUT);
    servo_vert.attach(servo_vert_pin);
    servo_gor.attach(servo_gor_pin);
    digitalWrite(manual_pin, HIGH);
}   

///////////////////////////////////////////////////////////////////
// Автоматическое управление
///////////////////////////////////////////////////////////////////

void ServoGor(boolean g)                           // функция поворота сервы горизонта
{
    int p;
    if(g==HIGH)
    {
      servo_gor_go = HIGH;
      servo_gor.attach(servo_gor_pin);               // подключаем серву горизонтальную
      for(p=1525; p<=1600; p++)
      {
        servo_gor.writeMicroseconds(p);
        delay(3);
      }
    }
    if(g==LOW)
    {
      servo_gor_go = LOW;
      for(p=1600; p>=1525; p--)
      {
        servo_gor.writeMicroseconds(p);
        delay(3);
      }
      servo_gor.detach();                             //отключаем серву горизонтальную
    }
}

void cycle()
{
    servo_gor.write(posr);
    servo_vert.write(posv2);
    delay(800);
    shutter();   
    delay(800);
    servo_vert.write(posv1);
    delay(800);
    shutter();   
    delay(800);
    ServoGor(HIGH);
    delay(400);
    ServoGor(LOW);
}

void shutter()
{
    nex.shutterNow();
}

void auto_loop()
{
    for (int i=0;i<9;i++)
      cycle();

    servo_vert.write(posv3);
    delay(800);
    shutter();   
    delay(800);
}

///////////////////////////////////////////////////////////////////
// Ручное управление
///////////////////////////////////////////////////////////////////
void manual_loop()
{
    digitalWrite(servo_gor_pin, digitalRead(manual_gor_pin));
    digitalWrite(servo_vert_pin, digitalRead(manual_vert_pin));
}
///////////////////////////////////////////////////////////////////
// Основной цикл
///////////////////////////////////////////////////////////////////

int is_manual = 0;

void loop()
{
    if (digitalRead(manual_pin) == HIGH)
    {
      if (is_manual != 1)
      {
        // Detach servo drivers
        if (servo_vert.attached() == true)   
          servo_vert.detach();

        if (servo_gor.attached() == true)
          servo_gor.detach();

        is_manual = 1;
      }

      manual_loop();
    }
    else
    {
      if (is_manual != 0)
      {
          if (servo_vert.attached() == false)   
          servo_vert.attach(servo_vert_pin);

        if (servo_gor.attached() == false)
          servo_gor.attach(servo_gor_pin);

        is_manual = 0;
      }

      auto_loop();
    }
}

pinMode(12, INPUT);   //12й пин – вход

int val;
val = digitalRead(12);

// Ручное управление  
///////////////////////////////////////////////////////////////////  
void manual_loop()  
{  
     digitalWrite(servo_gor_pin, digitalRead(manual_gor_pin));  
     digitalWrite(servo_vert_pin, digitalRead(manual_vert_pin));  
}

Servo myservo; // объявляем серву
int pin = 7;   // назначаем порт для сервы
int val;       // переменная для значения угла поворота сервы
//------------------
void setup()       
{       
        //---- для сервы ничего здесь не пишем
        //----         
}
//------------------
void loop() // исполняющая функция (может быть базовая может быть собственная какая нибудь)
{
              if(......)// если чего-то там, то
            {
              val = ........   // выясняем значение
              myservo.attach(pin); // открываем порт для сервы
              myservo.writeMicroseconds(val); // выполняем команду
              delay(30); // ждём выполнение этой команды (значение можно поставить больше или меньше зависит от характера команды)
              myservo.detach(); // закрываем порт для сервы
            }
}

Servo myservo; // объявляем серву
int pin = 7;   // назначаем порт для сервы
int val;       // переменная для значения угла поворота сервы
//------------------
void setup()       
{       
        //----
              myservo.attach(pin); // открываем порт для сервы
        //----         
}
//------------------
void loop() // исполняющая функция (может быть базовая может быть собственная какая нибудь)
{
              if(......)// если чего-то там, то
            {
              val = ........   // выясняем значение
              myservo.writeMicroseconds(val); // выполняем команду
              delay(30); // ждём выполнение этой команды (значение можно поставить больше или меньше зависит от характера команды)
            }
}

digitalWrite(servo_vert_pin, digitalRead(manual_vert_pin));   //не желательно

int val= digitalRead(manual_vert_pin);
digitalWrite(servo_vert_pin,val);                    //так лучше

int pin = 10;                //даём номер пина для входящего сигнала
int val_1=0;
int val_2=0;

void setup()                           
{
        pinMode(pin, INPUT);       // открываем порт, даём значение ВХОД
        Serial.begin(9600);        // полученные даннные будем записывать в COM-порт
}
void loop()                            
{
        val_1 = digitalRead(pin);    // считываем значение в цифровом режиме
        val_2 = analogRead(pin);    // считываем значение в аналоговом режиме
        Serial.print(val_1);      
        Serial.print("   ");       
        Serial.println(val_2);        // передаём значение на монитор компьютера
        delay(100);
}

int manual_pin       = 10;                   // пин включающий ручное управление с пульта       
//----
void setup()         
{         
          ............
          ............
          ............       
          digitalWrite(manual_pin, HIGH);  - вот здесь
}   

void manual_loop()       
{       
          digitalWrite(servo_gor_pin, digitalRead(manual_gor_pin));       
          digitalWrite(servo_vert_pin, digitalRead(manual_vert_pin));       
}   

int manual_pin       = 10;                   // пин включающий ручное управление с пульта        
//----  
void setup()          
{          
           ............  
           ............  
           ............        
           digitalWrite(manual_pin, HIGH);  - вот здесь  
}    

int servo_gor_pin = 7; // пин для сервы горизонтального поворота камеры
int servo_vert_pin = 6; // пин для сервы вертикального поворота камеры
int manual_gor_pin = 12; // вход сигнала с приёмника для горизонтальной сервы
int manual_vert_pin = 11; // вход сигнала с приёмника для вертикальной сервы

void manual_loop() //функция ручного управления (согласно вашему названию)
{
digitalWrite(servo_gor_pin, digitalRead(manual_gor_pin)); // на пин под номером 7 подаётся значение которое было считанное с порта под номером 12 и имеет значение [b]HIGH[/b] или [b]LOW[/b], естественно это ни как не шим а просто либо 0-3V либо 3-5V...
digitalWrite(servo_vert_pin, digitalRead(manual_vert_pin)); // то же самое что и вверху
}

servo.attach(servo_gor_pin); //объявляем пин 7 для сервы

val = map(analogRead(manual_gor_pin),0,1023,450,2200); // конвертируем значение считанное с пина 12 к которому подключен источник сигнала.    
servo.writeMicroseconds(val); // и подаём это значение на серву

void setup()  
{  
   //----   
   pinMode(10, INPUT);   //объявляем 10 пин как вход
   //----    
}

void loop()                       
{
   val = digitalRead(10);    // узнаём состояние кнопки
  if(val)                    // тоже самое что (val == HIGN)  // если 10 пин замкнут
     {.......}               // делаем какуюто каманду
  if(!val)                   // тоже что и val==LOW           // если 10 пин не замкнут
     {.......}               // делаем другую каманду
}

void setup()  
{  
   //----   
   pinMode(10, INPUT_PULLUP);   //подтягивающий резистор включен для пина 10
   //----    
}

void loop()                       
{
   val = digitalRead(10);    // узнаём состояние кнопки
  if(val)                    // тоже самое что (val == HIGN)  // если 10 пин замкнут
     {.......}               // делаем какуюто каманду
  if(!val)                   // тоже что и val==LOW           // если 10 пин не замкнут
     {.......}               // делаем другую каманду
}

#include <Servo.h>                
///////////////////////////////////////////////////////////////////
// Номера входов и выходов
///////////////////////////////////////////////////////////////////
int servo_vert_pin   = 6;                   // пин для сервы вертикального поворота камеры
int manual_vert_pin  = 11;                  // вход сигнала с приёмника для вертикальной сервы
int val;
///////////////////////////////////////////////////////////////////
// Объекты программы
///////////////////////////////////////////////////////////////////
Servo servo_vert;  // создаём объект для контроля сервы вертикального поворота
///////////////////////////////////////////////////////////////////
// Инициализация
///////////////////////////////////////////////////////////////////
void setup()   
{   
    pinMode(servo_vert_pin, OUTPUT);
    pinMode(manual_vert_pin, INPUT);
}   
///////////////////////////////////////////////////////////////////
// Основной цикл
///////////////////////////////////////////////////////////////////
void loop()
{
servo_vert.attach(servo_vert_pin);
val = map(analogRead(manual_vert_pin),0,1023,540,2200); // конвертируем значение считанное с пина 11 к которому подключен источник сигнала.      
servo_vert.writeMicroseconds(val); // и подаём это значение на серву
}

int val;
void setup() {
            Serial.begin(9600);        // полученные данные будем записывать в COM-порт     
}

void loop() {
      val = analogRead(0);    // считываем значение с потенциометра           
            Serial.println(val);        // передаём значение на монитор компьютера     
}

#include <Servo.h>               
#include <multiCameraIrControl.h>

///////////////////////////////////////////////////////////////////
// Номера входов и выходов
///////////////////////////////////////////////////////////////////

int servo_gor_pin    = 7;                   // пин для сервы горизонтального поворота камеры
int servo_vert_pin   = 6;                   // пин для сервы вертикального поворота камеры

int manual_pin       = 2;                    // пин включающий автоматическое/ручного управление и спуск затвора с пульта
int manual_gor_pin   = 12;                   // вход сигнала с приёмника для горизонтальной сервы
int manual_vert_pin  = 11;                  // вход сигнала с приёмника для вертикальной сервы

///////////////////////////////////////////////////////////////////
// Объекты программы
///////////////////////////////////////////////////////////////////

Servo servo_gor;                            // создаём объект для контроля сервы горизонтального поворота
Servo servo_vert;
Sony nex(9);

///////////////////////////////////////////////////////////////////
// Переменные программы
///////////////////////////////////////////////////////////////////

boolean servo_gor_go = LOW;
int posv1 = 70;
int posv2 = 100;
int posv3 = 50;
int posr = 92;
unsigned long  micros_prev = 0;
volatile unsigned int time = 0;

///////////////////////////////////////////////////////////////////
// Инициализация
///////////////////////////////////////////////////////////////////

void setup()  
{  

   pinMode(servo_vert_pin, OUTPUT);
   pinMode(servo_gor_pin, OUTPUT);
   pinMode(manual_vert_pin, INPUT);
   pinMode(manual_gor_pin, INPUT);
   pinMode(manual_pin, INPUT);
   servo_vert.attach(servo_vert_pin);
   servo_gor.attach(servo_gor_pin);
   Serial.begin(115200);
   Serial.println("Starting up!");

   digitalWrite(manual_pin, HIGH);   
   attachInterrupt(0, Mode, CHANGE);
}  

void Mode()
{
   if(PIND&1<<2){
     micros_prev = micros();
   }
   else{
     time = micros() - micros_prev;
   }
}
///////////////////////////////////////////////////////////////////
// Автоматическое управление
///////////////////////////////////////////////////////////////////

void ServoGor(boolean g)                           // функция поворота сервы горизонта
{
   int p;
   if(g==HIGH)
   {
     servo_gor_go = HIGH;
     servo_gor.attach(servo_gor_pin);               // подключаем серву горизонтальную
     for(p=1525; p<=1600; p++)
     {
       servo_gor.writeMicroseconds(p);
       delay(3);
     }
   }
   if(g==LOW)
   {
     servo_gor_go = LOW;
     for(p=1600; p>=1525; p--)
     {
       servo_gor.writeMicroseconds(p);
       delay(3);
     }
     servo_gor.detach();                             //отключаем серву горизонтальную
   }
}

void cycle()
{
   servo_gor.write(posr);
   servo_vert.write(posv2);
   delay(800);
   shutter();  
   delay(800);
   servo_vert.write(posv1);
   delay(800);
   shutter();  
   delay(800);
   ServoGor(HIGH);
   delay(400);
   ServoGor(LOW);
}

void shutter()
{
   nex.shutterNow();
}

void auto_loop()
{
   for (int i=0;i<9;i++)
     cycle();

   servo_vert.write(posv3);
   delay(800);
   shutter();  
   delay(800);
}

///////////////////////////////////////////////////////////////////
// Ручное управление
///////////////////////////////////////////////////////////////////
void manual_loop()
{  
   DDRD |= (1<<6) | (1<<7);                // Настраиваем 6 и 7 выводы на выход
   while(time > 1700){                    
     PINB&1<<4?PORTD|=1<<7:PORTD&=~(1<<7); // Если на 12 выводе 1, то на 7 вывод даем 1, иначе 0
     PINB&1<<3?PORTD|=1<<6:PORTD&=~(1<<6); // Если на 11 выводе 1, то на 6 вывод даем 1, иначе 0
   }
}
///////////////////////////////////////////////////////////////////
// Основной цикл
///////////////////////////////////////////////////////////////////

int is_manual = 0;

void loop()
{
   if (time < 1300)
     shutter();
   else if (time > 1700)
   {
     if (is_manual != 1)
     {
       Serial.println("Manual mode is on\r\n");

       // Detach servo drivers
       if (servo_vert.attached() == true)  
         servo_vert.detach();

       if (servo_gor.attached() == true)
         servo_gor.detach();
       is_manual = 1;
     }

     manual_loop();
   }
   else
   {
     if (is_manual != 0)
     {
       Serial.println("Automatic mode is on\r\n");

       if (servo_vert.attached() == false)  
         servo_vert.attach(servo_vert_pin);

       if (servo_gor.attached() == false)
         servo_gor.attach(servo_gor_pin);

       is_manual = 0;
     }

     auto_loop();
   }
}

#include <Servo.h>               
#include <multiCameraIrControl.h>

///////////////////////////////////////////////////////////////////
// Номера входов и выходов
///////////////////////////////////////////////////////////////////

int servo_gor_pin    = 7;                   // пин для сервы горизонтального поворота камеры
int servo_vert_pin   = 6;                   // пин для сервы вертикального поворота камеры

int manual_photo_pin = 3;                    //пин включающий ИК (канал AUX1 на передатчике)
int manual_pin       = 2;                    // пин включающий автоматическое/ручное управление (канал AUX2 на передатчике)

int manual_gor_pin   = 12;                   // вход сигнала с приёмника для горизонтальной сервы
int manual_vert_pin  = 11;                   // вход сигнала с приёмника для вертикальной сервы

///////////////////////////////////////////////////////////////////
// Объекты программы
///////////////////////////////////////////////////////////////////

Servo servo_gor;                            // создаём объект для контроля сервы горизонтального поворота
Servo servo_vert;                           //создаём объект для контроля сервы вертикального поворота
Nikon nex(9);                    // ИК диод для управления затвором

///////////////////////////////////////////////////////////////////
// Переменные программы
///////////////////////////////////////////////////////////////////

boolean servo_gor_go = LOW;
int posv1 = 70; //позиции вертикальной сервы
int posv2 = 100;
int posv3 = 50;
int posr = 92;
unsigned long  micros_prev = 0;      ////канал AUX2
volatile unsigned int time = 1900;
unsigned long  micros_prev1 = 0;     ////канал AUX1
volatile unsigned int time1 = 1900;

///////////////////////////////////////////////////////////////////
// Инициализация
///////////////////////////////////////////////////////////////////

void setup()  
{  
   pinMode(servo_vert_pin, OUTPUT);
   pinMode(servo_gor_pin, OUTPUT);
   pinMode(manual_vert_pin, INPUT);
   pinMode(manual_gor_pin, INPUT);
   pinMode(manual_pin, INPUT);
   pinMode(manual_photo_pin, INPUT);
    
   servo_vert.attach(servo_vert_pin);
   servo_gor.attach(servo_gor_pin);
    
   digitalWrite(manual_pin, HIGH);        ///AUX2
   attachInterrupt(0, Mode, CHANGE);
    
   digitalWrite(manual_photo_pin, HIGH);  ////AUX1
   attachInterrupt(1, Mode1, CHANGE);
   delay(2000);  
}  

void Mode()  ////чтение канала AUX2 (переключение между авто\ручным управлением)
{
   if(PIND&1<<2){
     micros_prev = micros();
   }
   else{
     time = micros() - micros_prev;
   }
}

void Mode1()    ////чтение канала AUX1 (спуск затвора)
{
   if(PIND&1<<3){
     micros_prev1 = micros();
   }
   else{
     time1 = micros() - micros_prev1;
   }
}

///////////////////////////////////////////////////////////////////
// Автоматическое управление
///////////////////////////////////////////////////////////////////

void ServoGor(boolean g)                           // функция поворота сервы горизонта
{
   int p;
   if(g==HIGH)
   {
     servo_gor_go = HIGH;
     servo_gor.attach(servo_gor_pin);               // подключаем серву горизонтальную
     for(p=1525; p<=1600; p++)
     {
       servo_gor.writeMicroseconds(p);
       delay(3);
     }
   }
   if(g==LOW)
   {
     servo_gor_go = LOW;
     for(p=1600; p>=1525; p--)
     {
       servo_gor.writeMicroseconds(p);
       delay(3);
     }
     servo_gor.detach();                             //отключаем серву горизонтальную
   }
}

void cycle()    //панорамный цикл
{
while(time < 1700){  
   servo_gor.write(posr);
   servo_vert.write(posv2);
   delay(800);
   shutter();  
   delay(800);
   servo_vert.write(posv1);
   delay(800);
   shutter();  
   delay(800);
   ServoGor(HIGH);
   delay(400);
   ServoGor(LOW);
}
}

void shutter()   // спуск затвора
{
   nex.shutterNow();
}

void auto_loop() //полный цикл автоматического управления
{  
   
   for (int i=0;i<9;i++)
   cycle();
   if(time < 1700){
   servo_vert.write(posv3); //съемка надира
   delay(800);
   shutter();  
   delay(800);
}
}

///////////////////////////////////////////////////////////////////
// Ручное управление
///////////////////////////////////////////////////////////////////

void manual_loop() //цикл ручного управления сервами с передатчика
{  

   DDRD |= (1<<6) | (1<<7);                // Настраиваем 6 и 7 выводы на выход
   boolean flag = 0;
   while(time > 1700){  
     if(time1 < 1700){
       if(!flag){
         nex.shutterNow();  
         flag = 1;
       }
     }
     else flag = 0;       
     PINB&1<<4?PORTD|=1<<7:PORTD&=~(1<<7); // Если на 12 выводе 1, то на 7 вывод даем 1, иначе 0
     PINB&1<<3?PORTD|=1<<6:PORTD&=~(1<<6); // Если на 11 выводе 1, то на 6 вывод даем 1, иначе 0
   }
}
///////////////////////////////////////////////////////////////////
// Основной цикл
///////////////////////////////////////////////////////////////////
void loop()
{  
    if (time > 1700)
   {
     servo_vert.detach();
     servo_gor.detach();
     manual_loop();
     servo_vert.attach(servo_vert_pin);
     servo_gor.attach(servo_gor_pin);
   }
   else  
     auto_loop();
}