Arduino.ru

дальше вы говорите что у вас там две сервы. Так что так

/**/
unsigned long mill; // переменная под millis()
//--------------------------------
#include <Servo.h>
class Cl_Servo {
  protected:
    Servo servo; // сервопривод
    byte pin;
  public:
    Cl_Servo(byte p): pin(p) {}
    void init() {}
    void run() {}
};
//--------------------------------
class Cl_Unit {
  protected:
    Cl_Servo Servo1;
    Cl_Servo Servo2;
  public:
    Cl_Unit(byte p1, byte p2)
      : Servo1(p1), Servo2(p2) {}
    void init() {
      Servo1.init();
      Servo2.init();
    }
    void run() {
      Servo1.run();
      Servo2.run();
    }
};
//---Компоновка-----------------------------
Cl_Unit Unit(/*серва1*/2,/*серва2*/3);
//---main-----------------------------
void setup() {
  Unit.init();
}


void loop() {
  mill = millis();
  Unit.run();
}
/**/

 

Ну а дальше по воздействию с пина устройство начинает работать или же останавливаться

/**/
unsigned long mill; // переменная под millis()
typedef void (*pDo)() ;// тип -функция обработчик
//--------------------------------
#include <Servo.h>
class Cl_Servo {
  protected:
    Servo servo; // сервопривод
    byte pin;
  public:
    Cl_Servo(byte p): pin(p) {}
    void init() {}
    void run() {}
};
//--------------------------------
class Cl_Unit {
  protected:
    Cl_Servo Servo1;
    Cl_Servo Servo2;
  public:
    Cl_Unit(byte p1, byte p2)
      : Servo1(p1), Servo2(p2) {}
    void init() {
      Servo1.init();
      Servo2.init();
    }
    void run() {
      Servo1.run();
      Servo2.run();
    }
    void start() {}
    void stop() {}
};
class Cl_Control {
  protected:
    pDo Do1, Do2;
    byte pin;
  public:
    Cl_Control(byte p, pDo D1, pDo D2)
      : pin(p), Do1(D1), Do2(D2) {}
    void init() {}
    void run() {}
};
//---Компоновка-----------------------------
Cl_Unit Unit(/*серва1*/2,/*серва2*/3);
void DoStart() {
  Unit.start();
}
void DoStop() {
  Unit.stop();
}
Cl_Control Control(/*пин*/4,/*запуск*/DoStart,/*останов*/DoStop);
//---main-----------------------------
void setup() {
  Unit.init();
  Control.init();
}


void loop() {
  mill = millis();
  Unit.run();
  Control.init();
}
/**/

ПС: Ничего вроде нового. Но уже ясно что и как делать дальше.

А mill - это коэффициент Квона, если я правильно понимаю?

Разумеется если  скетч повыше залить в плату, то ничего он делать не будет. Это немного скучно. Попробуем немного поменять и подключив кнопки на 4 и 5 пины можем в сериал наблюдать работу этих кнопок, при помощи которых мы сможем в будущем управлять устройством.

/**/
unsigned long mill; // переменная под millis()
typedef void (*pDo)() ;// тип -функция обработчик
//--------------------------------
#include <Servo.h>
class Cl_Servo {
  protected:
    Servo servo; // сервопривод
    byte pin;
  public:
    Cl_Servo(byte p): pin(p) {}
    void init() {}
    void run() {}
};
//--------------------------------
class Cl_Unit {
  protected:
    Cl_Servo Servo1;
    Cl_Servo Servo2;
  public:
    Cl_Unit(byte p1, byte p2)
      : Servo1(p1), Servo2(p2) {}
    void init() {
      Servo1.init();
      Servo2.init();
    }
    void run() {
      Servo1.run();
      Servo2.run();
    }
    void start() {}
    void stop() {}
};
//------Cl_Btn----------------------
// класс кнопка
class Cl_Btn {
  protected:
    const byte pin;
    pDo Do;//обработчик
    bool bounce = 0;
    bool btn = 1, oldBtn;
    unsigned long past;
  public:
    /*конструктор*/
    Cl_Btn(byte pin_, pDo Do_): pin(pin_), Do(Do_) {}
    /*инициализация-вставить в setup()*/
    void init() {
      pinMode(pin, INPUT_PULLUP);
    }
    /*работа-вставить в loop()*/
    void run() {
      bool newBtn = digitalRead(pin);
      if (!bounce && newBtn != btn) {
        bounce = 1;
        past = mill;
      }
      if (bounce && mill - past >= 10) {
        bounce = 0 ;
        oldBtn = btn;
        btn = newBtn;
        if (!btn && oldBtn) Do();
      }
    }
};
//---Компоновка-----------------------------
Cl_Unit Unit(/*серва1*/2,/*серва2*/3);
void DoStart() {
  Unit.start();
  Serial.println("Start");
}
void DoStop() {
  Unit.stop();
  Serial.println("Stop");
}
Cl_Btn Btn1(/*пин*/4,/*обработчик*/DoStart);
Cl_Btn Btn2(/*пин*/5,/*обработчик*/DoStop);
//---main-----------------------------
void setup() {
  Serial.begin(9600);
  Unit.init();
  Btn1.init();
  Btn2.init();
}


void loop() {
  mill = millis();
  Unit.run();
  Btn1.run();
  Btn2.run();
}
/**/

 

Разумеется, что я забылся: зафигачить в класс неизвестно как модифицирующуюся глобальную переменную - это высший пилотаж.

Конечно переписать скетч можно согласно темы http://arduino.ru/forum/programmirovanie/tsifrovye-avtomaty-v-klassakh-po-qwone

/**/
unsigned long mill; // переменная под millis()
typedef void (*pDo)() ;// тип -функция обработчик
//--------------------------------
#include <Servo.h>
class Cl_Servo {
  protected:
    Servo servo; // сервопривод
    byte pin;
  public:
    Cl_Servo(byte p): pin(p) {}
    void init() {}
    void run() {}
};
//--------------------------------
class Cl_Unit {
  protected:
    Cl_Servo Servo1;
    Cl_Servo Servo2;
  public:
    Cl_Unit(byte p1, byte p2)
      : Servo1(p1), Servo2(p2) {}
    void init() {
      Servo1.init();
      Servo2.init();
    }
    void run() {
      Servo1.run();
      Servo2.run();
    }
    void start() {}
    void stop() {}
};
//------Cl_Btn----------------------
// класс кнопка
class Cl_Btn {
  public:
    enum  event_t {eNone, eClick}; /*событие ничего/клик*/
  protected:
    const byte pin;
    event_t event;
    bool bounce = 0;
    bool btn = 1, oldBtn;
    unsigned long past;
  public:
    bool is (event_t e) {
      return e == event;
    }
    Cl_Btn(byte p): pin(p) {}
    void init() {
      pinMode(pin, INPUT_PULLUP);
    }
    void run() {
      event = eNone;
      bool newBtn = digitalRead(pin);
      if (!bounce && newBtn != btn) {
        bounce = 1;
        past = mill;
      }
      if (bounce && mill - past >= 10) {
        bounce = 0 ;
        oldBtn = btn;
        btn = newBtn;
        if (!btn && oldBtn) event = eClick;
      }
    }
};
//---Компоновка-----------------------------
Cl_Unit Unit(/*серва1*/2,/*серва2*/3);
void DoStart() {
  Unit.start();
  Serial.println("Start");
}
void DoStop() {
  Unit.stop();
  Serial.println("Stop");
}
Cl_Btn Btn1(/*пин*/4);
Cl_Btn Btn2(/*пин*/5);
//---main-----------------------------
void setup() {
  Serial.begin(9600);
  Unit.init();
  Btn1.init();
  Btn2.init();
}


void loop() {
  mill = millis();
  Unit.run();
  Btn1.run();
  Btn2.run();
  if (Btn1.is(Cl_Btn::eClick)) DoStart();
  if (Btn2.is(Cl_Btn::eClick)) DoStop();
}
/**/

 

Пора Квона отправлять из Николаева в Красный Яр. Там ему DetSemen голову-то прочистит православным Керниганом, Ритчем и самогоном. А то, смотрю, классофилия прогрессирует.

Или вообще перевести управление на Serial  s- старт а x- стоп

/**/
unsigned long mill; // переменная под millis()
typedef void (*pDo)() ;// тип -функция обработчик
//--------------------------------
#include <Servo.h>
class Cl_Servo {
  protected:
    Servo servo; // сервопривод
    byte pin;
  public:
    Cl_Servo(byte p): pin(p) {}
    void init() {}
    void run() {}
};
//--------------------------------
class Cl_Unit {
  protected:
    Cl_Servo Servo1;
    Cl_Servo Servo2;
  public:
    Cl_Unit(byte p1, byte p2)
      : Servo1(p1), Servo2(p2) {}
    void init() {
      Servo1.init();
      Servo2.init();
    }
    void run() {
      Servo1.run();
      Servo2.run();
    }
    void start() {}
    void stop() {}
};
//--------------------Cl_sKeyboard--------------------------------
/*состояние-нет нажатий/правая/левая/вверх/вниз/влево/выбор*/
enum event_t {skNone = 0, skStart, skStop};
struct com_t {
  byte com;
  byte event;
};
const byte numCom = 3;
const com_t MAP[numCom] PROGMEM = {
  {'s', event_t::skStart}, {'x', event_t::skStop}
};
class Cl_sKeyboard {
  protected:
    event_t event = event_t::skNone;
  public:
    bool is (event_t e) {
      return e == event;
    }
    Cl_sKeyboard() {}
    void init() {
      Serial.begin(9600);
    }
    void run() {
      event = event_t::skNone;
      if (Serial.available() > 0) {
        byte a = Serial.read();
        for (int i = 0; i < numCom; i++) {
          if (a == pgm_read_byte(&(MAP[i].com))) {
            event = (event_t)pgm_read_byte(&(MAP[i].event));
            break;
          }
        }
      }
    }
};
//---Компоновка-----------------------------
Cl_Unit Unit(/*серва1*/2,/*серва2*/3);
void DoStart() {
  Unit.start();
  Serial.println("Start");
}
void DoStop() {
  Unit.stop();
  Serial.println("Stop");
}
Cl_sKeyboard Keyboard;
//---main-----------------------------
void setup() {
  Serial.begin(9600);
  Unit.init();
  Keyboard.init();
}


void loop() {
  mill = millis();
  Unit.run();
  Keyboard.run();
  if (Keyboard.is(event_t::skStart)) DoStart();
  if (Keyboard.is(event_t::skStop)) DoStop();
}
/**/

 

Нет, я его фтопку закину сразу.  Дрова мне нужны. 

Допустим нам захотелось что бы уствойство двигалось по циклу в 5 шагов. Тогда скетч станет таким

/**/
unsigned long mill; // переменная под millis()
typedef void (*pDo)() ;// тип -функция обработчик
//--------------------------------
#include <Servo.h>
class Cl_Servo {
  protected:
    Servo servo; // сервопривод
    byte pin;
  public:
    Cl_Servo(byte p): pin(p) {}
    void init() {}
    void run() {}
};
//--------------------------------
class Cl_Unit {
  protected:
    Cl_Servo Servo1;
    Cl_Servo Servo2;

    unsigned long past;
    const unsigned long time = 500; /*временноц промежуток*/
    enum state_t {sNone, sOne, sTwo, sThree, sFour, sFive} state;
    void stand(state_t s) {
      state = s;
      past = mill;
      switch (state) {
        case sNone:
          Serial.println("None");
          break;
        case sOne:
          Serial.println("One");
          break;
        case sTwo:
          Serial.println("Two");
          break;
        case sThree:
          Serial.println("Three");
          break;
        case sFour:
          Serial.println("Four");
          break;
        case sFive:
          Serial.println("Five");
          break;
      }
    }
    bool is(state_t s, unsigned long t) {
      return (s == state && mill - past >= t);
    }
  public:
    Cl_Unit(byte p1, byte p2)
      : Servo1(p1), Servo2(p2) {}
    void init() {
      Servo1.init();
      Servo2.init();
    }
    void run() {
      Servo1.run();
      Servo2.run();
      if (is(sOne,  time)) stand(sTwo);
      if (is(sTwo,  time)) stand(sThree);
      if (is(sThree, time)) stand(sFour);
      if (is(sFour, time)) stand(sFive);
      if (is(sFive, time)) stand(sOne);
    }
    void start() {
      stand(sOne);
    }
    void stop() {
      stand(sNone);
    }
};
//--------------------Cl_sKeyboard--------------------------------
/*состояние-нет нажатий/правая/левая/вверх/вниз/влево/выбор*/
enum event_t {skNone = 0, skStart, skStop};
struct com_t {
  byte com;
  byte event;
};
const byte numCom = 3;
const com_t MAP[numCom] PROGMEM = {
  {'s', event_t::skStart}, {'x', event_t::skStop}
};
class Cl_sKeyboard {
  protected:
    event_t event = event_t::skNone;
  public:
    bool is (event_t e) {
      return e == event;
    }
    Cl_sKeyboard() {}
    void init() {
      Serial.begin(9600);
    }
    void run() {
      event = event_t::skNone;
      if (Serial.available() > 0) {
        byte a = Serial.read();
        for (int i = 0; i < numCom; i++) {
          if (a == pgm_read_byte(&(MAP[i].com))) {
            event = (event_t)pgm_read_byte(&(MAP[i].event));
            break;
          }
        }
      }
    }
};
//---Компоновка-----------------------------
Cl_Unit Unit(/*серва1*/2,/*серва2*/3);
void DoStart() {
  Unit.start();
}
void DoStop() {
  Unit.stop();
}
Cl_sKeyboard Keyboard;
//---main-----------------------------
void setup() {
  Serial.begin(9600);
  Unit.init();
  Keyboard.init();
}
void loop() {
  mill = millis();
  Unit.run();
  Keyboard.run();
  if (Keyboard.is(event_t::skStart)) DoStart();
  if (Keyboard.is(event_t::skStop)) DoStop();
}
/**/

 

Но думаю так скучно. Пусть будет 3 варианта f-вперед b-назад s-стоп

/**/
unsigned long mill; // переменная под millis()
typedef void (*pDo)() ;// тип -функция обработчик
//--------------------------------
#include <Servo.h>
class Cl_Servo {
  protected:
    Servo servo; // сервопривод
    byte pin;
  public:
    Cl_Servo(byte p): pin(p) {}
    void init() {}
    void run() {}
};
//--------------------------------
class Cl_Unit {
  protected:
    Cl_Servo Servo1;
    Cl_Servo Servo2;

    unsigned long past;
    const unsigned long time = 500; /*временноц промежуток*/
    enum state_t {sNone = 0, sOne, sTwo, sThree, sFour, sFive} state;
    enum state2_t {sForward = 0, sBackward} state2;
    void stand(state_t s) {
      state = s;
      past = mill;
      switch (state) {
        case sNone:
          Serial.println("None");
          break;
        case sOne:
          Serial.println("One");
          break;
        case sTwo:
          Serial.println("Two");
          break;
        case sThree:
          Serial.println("Three");
          break;
        case sFour:
          Serial.println("Four");
          break;
        case sFive:
          Serial.println("Five");
          break;
      }
    }
    void stand(state2_t s) {
      state2 = s;
    }
    bool is(state_t s, unsigned long t) {
      return (s == state && mill - past >= t);
    }
    bool is(state2_t s) {
      return (s == state2);
    }
  public:
    Cl_Unit(byte p1, byte p2)
      : Servo1(p1), Servo2(p2) {}
    void init() {
      Servo1.init();
      Servo2.init();
    }
    void run() {
      Servo1.run();
      Servo2.run();
      if (is(sForward)) {
        if (is(sOne,  time)) stand(sTwo);
        if (is(sTwo,  time)) stand(sThree);
        if (is(sThree, time)) stand(sFour);
        if (is(sFour, time)) stand(sFive);
        if (is(sFive, time)) stand(sOne);
      }
      else if (is(sBackward)) {
        if (is(sOne,  time)) stand(sFive);
        if (is(sTwo,  time)) stand(sOne);
        if (is(sThree, time)) stand(sTwo);
        if (is(sFour, time)) stand(sThree);
        if (is(sFive, time)) stand(sFour);
      }
    }
    void forward() {
      stand(sForward);
      stand(sOne);
    }
    void backward() {
      stand(sBackward);
      stand(sOne);
    }
    void stop() {
      stand(sNone);
    }
};
//--------------------Cl_sKeyboard--------------------------------
/*состояние-нет нажатий/правая/левая/вверх/вниз/влево/выбор*/
enum event_t {skNone = 0, skForward, skBackward, skStop};
struct com_t {
  byte com;
  byte event;
};
const byte numCom = 3;
const com_t MAP[numCom] PROGMEM = {
  {'f', event_t::skForward}, {'b', event_t::skBackward}, {'s', event_t::skStop}
};
class Cl_sKeyboard {
  protected:
    event_t event = event_t::skNone;
  public:
    bool is (event_t e) {
      return e == event;
    }
    Cl_sKeyboard() {}
    void init() {
      Serial.begin(9600);
    }
    void run() {
      event = event_t::skNone;
      if (Serial.available() > 0) {
        byte a = Serial.read();
        for (int i = 0; i < numCom; i++) {
          if (a == pgm_read_byte(&(MAP[i].com))) {
            event = (event_t)pgm_read_byte(&(MAP[i].event));
            break;
          }
        }
      }
    }
};
//---Компоновка-----------------------------
Cl_Unit Unit(/*серва1*/2,/*серва2*/3);
Cl_sKeyboard Keyboard;
//---main-----------------------------
void setup() {
  Serial.begin(9600);
  Unit.init();
  Keyboard.init();
}
void loop() {
  mill = millis();
  Unit.run();
  Keyboard.run();
  if (Keyboard.is(event_t::skForward))  Unit.forward();
  if (Keyboard.is(event_t::skBackward)) Unit.backward();
  if (Keyboard.is(event_t::skStop))     Unit.stop();
}
/**/

 

А я думал, только военные могут называть энергию мощностью, да еще и изменять в единицах массы (АКА в килотоннах).

Уважаемый qwone, ОГРОМНОЕ Вам спасибо за этот очень важный для меня урок !!! Я очень постараюсь всё это разложить "по косточкам" и во всём разобраться...Судя по комментариям у Вас тут весёлая компания собралась )))... я сам люблю шутки и уважаю Вас что Вы на шутки не обижаетесь...НО хочу заметить что тут напрасно люди ёрничают в Ваш адрес, ведь из всех возможно десятков или сотен опытных программистов на этом сайте на мою просьбу о помощи серьёзно откликнулись только Вы qwone !!!  Так что искренне Вам признателен.  

...

 

...ни в коем случае даже не пытаюсь с Вами спорить (мои знания в вашей области стремятся к нулю)... но хочу заметить что все скетчи qwona замечательно работают...)

...ну с точки зрения Теоретических основ электротехники мощность это и вовсе ВольтАмперы (полная мощность) или Ватты(активная) или Вары если мощность реактивная...а сточки зрения общей физики Ватт это Джоуль/секунду т.е. мощность это работа в 1 Джоуль в течении 1 секунды...так что всё верно...ну и конечно же мощность это энергия и если вспомнить закон Джоуля-Ленца то получим Q=Iквадрат*R*t где квадрат тока умнож. на сопротивление это МОЩНОСТЬ потерь а ЭНЕРГИЮ (количество тепла) мы получаем после умножения на время...

С чего ты взял? Ты просто не умеешь тестировать программыю Тестировщик - этоотдельная и весьма нехилая квалификация в программировании.

Так может Вы и правильно думали. Мы ж не знаем, кто придумал эту шутку. Может, военные. Я знаю только, что англоязычные, т.к. читал я её по-английски, а по-русски она не звучит вовсе.

Добавил повороты , а так же время написания скетча. Упрвление - f,b,r,l,s,?

/**/
unsigned long mill; // переменная под millis()
typedef void (*pDo)() ;// тип -функция обработчик
//--------------------------------
#include <Servo.h>
class Cl_Servo {
  protected:
    Servo servo; // сервопривод
    byte pin;
  public:
    Cl_Servo(byte p): pin(p) {}
    void init() {}
    void run() {}
};
//--------------------------------
class Cl_Unit {
  protected:
    Cl_Servo Servo1;
    Cl_Servo Servo2;

    unsigned long past;
    const unsigned long time = 500; /*временноц промежуток*/
    enum state_t {
      sNone = 0 /*нет шагов*/
      , sOne, sTwo, sThree, sFour   , sFive /*шаги вперед назад*/
      , sUno, sDue, sTre  , sQuattro, sCinque /*шаги вправо влево*/
    } state;
    enum direction_t {
      sStop = 0
      , sForward, sBackward
      , sRight, sLeft
    } direction;
    void stand(state_t s) {
      state = s;
      past = mill;
      switch (state) {
        case sNone:
          Serial.println("Stop");
          break;
        case sOne:
          Serial.println("One");
          break;
        case sTwo:
          Serial.println("Two");
          break;
        case sThree:
          Serial.println("Three");
          break;
        case sFour:
          Serial.println("Four");
          break;
        case sFive:
          Serial.println("Five");
          break;
        case sUno:
          Serial.println("Uno");
          break;
        case sDue:
          Serial.println("Due");
          break;
        case sTre:
          Serial.println("Tre");
          break;
        case sQuattro:
          Serial.println("Quattro");
          break;
        case sCinque:
          Serial.println("Cinque");
          break;
      }
    }
    void stand(direction_t s) {
      direction = s;
    }
    bool is(state_t s, unsigned long t) {
      return (s == state && mill - past >= t);
    }
    bool is(direction_t s) {
      return (s == direction);
    }
  public:
    Cl_Unit(byte p1, byte p2)
      : Servo1(p1), Servo2(p2) {}
    void init() {
      Servo1.init();
      Servo2.init();
    }
    void run() {
      Servo1.run();
      Servo2.run();
      if (is(sForward)) {
        if (is(sOne,  time)) stand(sTwo);
        if (is(sTwo,  time)) stand(sThree);
        if (is(sThree, time)) stand(sFour);
        if (is(sFour, time)) stand(sFive);
        if (is(sFive, time)) stand(sOne);
      }
      else if (is(sBackward)) {
        if (is(sOne,  time)) stand(sFive);
        if (is(sTwo,  time)) stand(sOne);
        if (is(sThree, time)) stand(sTwo);
        if (is(sFour, time)) stand(sThree);
        if (is(sFive, time)) stand(sFour);
      }
      else if (is(sRight)) {
        if (is(sUno,  time)) stand(sDue);
        if (is(sDue,  time)) stand(sTre);
        if (is(sTre, time))  stand(sQuattro);
        if (is(sQuattro, time)) stand(sCinque);
        if (is(sCinque, time)) stand(sUno);
      }
      else if (is(sLeft)) {
        if (is(sUno,  time)) stand(sCinque);
        if (is(sDue,  time)) stand(sUno);
        if (is(sThree, time)) stand(sDue);
        if (is(sQuattro, time)) stand(sThree);
        if (is(sCinque, time)) stand(sQuattro);
      }
    }
    void stop() {
      if (is(sStop)) return;
      stand(sNone);
    }
    void forward() {
      if (is(sForward)) return;
      if (!is(sBackward)) stand(sOne);
      stand(sForward);
    }
    void backward() {
      if (is(sBackward)) return;
      if (!is(sForward)) stand(sOne);
      stand(sBackward);
    }
    void right() {
      if (is(sRight)) return;
      if (!is(sLeft)) stand(sUno);
      stand(sRight);

    }
    void left() {
      if (is(sLeft)) return;
      if (!is(sRight)) stand(sUno);
      stand(sLeft);
    }
};
//--------------------Cl_sKeyboard--------------------------------
/*состояние-нет нажатий/правая/левая/вверх/вниз/влево/выбор*/
enum event_t {skNone = 0, skForward, skBackward, skLeft, skRight,  skStop,  skVer};
struct com_t {
  byte com;
  byte event;
};
const byte numCom = 6;
const com_t MAP[numCom] PROGMEM = {
  {'f', event_t::skForward}, {'b', event_t::skBackward}
  , {'l', event_t::skLeft}, {'r', event_t::skRight}
  , {'s', event_t::skStop}, {'?', event_t::skVer}
};
class Cl_sKeyboard {
  protected:
    event_t event = event_t::skNone;
  public:
    bool is (event_t e) {
      return e == event;
    }
    Cl_sKeyboard() {}
    void init() {
      Serial.begin(9600);
    }
    void run() {
      event = event_t::skNone;
      if (Serial.available() > 0) {
        byte a = Serial.read();
        for (int i = 0; i < numCom; i++) {
          if (a == pgm_read_byte(&(MAP[i].com))) {
            event = (event_t)pgm_read_byte(&(MAP[i].event));
            break;
          }
        }
      }
    }
};
//---Компоновка-----------------------------
Cl_Unit Unit(/*серва1*/2,/*серва2*/3);
Cl_sKeyboard Keyboard;
//---main-----------------------------
void setup() {
  Serial.begin(9600);
  Unit.init();
  Keyboard.init();
}
void loop() {
  mill = millis();
  Unit.run();
  Keyboard.run();
  if (Keyboard.is(event_t::skForward))  Unit.forward();
  if (Keyboard.is(event_t::skBackward)) Unit.backward();
  if (Keyboard.is(event_t::skLeft))  Unit.left();
  if (Keyboard.is(event_t::skRight)) Unit.right();
  if (Keyboard.is(event_t::skStop))  Unit.stop();
  if (Keyboard.is(event_t::skVer))   Serial.println("15/08/2018");;
}
/**/

 

Согласен много чего не знаю пока...но собрать схемку и загрузить скетч могу)

Из этого никак не следует, что ты можешь оценить работоспособность программы. Это (оценка работоспособности) очень серьёзная квалификация. Не каждый профессиональный программист может, а уж чайники - и разговора нет.

...ну да если говорить о серьёзных программах то там должно быть всё вылизано...

управление сервой с помощью Serial - a,b,c,d,e

/**/
unsigned long mill;
//------------------------------
#include <Servo.h>
class Cl_AAA {
    byte pin;
    Servo _Servo;
    byte val;
  public:
    enum state_t {sFree, sBusy};
    bool is(state_t s) {
      return (state == s);
    }
  protected:
    unsigned long past;
    const unsigned long time = 500;
    state_t  state;
    void stand(state_t s) {
      state = s;
      past = mill;
    }
    bool is(state_t s, unsigned long t) {
      return (state == s && mill - past >= t);
    }
  public:
    Cl_AAA(byte p): pin(p) {}
    void init() {
      _Servo.attach(pin);
      write(0);
    }
    void run() {
      if (is(sBusy, time)) stand(sFree);
    }
    void write(int v) {
      if (is(sBusy)) return;
      stand(sBusy);
      _Servo.write(val = v);
    }
};
//--------------------Cl_sKeyboard--------------------------------
/*состояние-нет нажатий/правая/левая/вверх/вниз/влево/выбор*/
enum event_t {skNone = 0, skA, skB, skC, skD,  skE,  skVer};
struct com_t {
  byte com;
  byte event;
};
const byte numCom = 6;
const com_t MAP[numCom] PROGMEM = {
  {'a', event_t::skA}, {'b', event_t::skB}
  , {'c', event_t::skC}, {'d', event_t::skD}
  , {'e', event_t::skE}, {'?', event_t::skVer}
};
class Cl_sKeyboard {
  protected:
    event_t event = event_t::skNone;
  public:
    bool is (event_t e) {
      return e == event;
    }
    Cl_sKeyboard() {}
    void init() {
      Serial.begin(9600);
    }
    void run() {
      event = event_t::skNone;
      if (Serial.available() > 0) {
        byte a = Serial.read();
        for (int i = 0; i < numCom; i++) {
          if (a == pgm_read_byte(&(MAP[i].com))) {
            event = (event_t)pgm_read_byte(&(MAP[i].event));
            break;
          }
        }
      }
    }
};
//------------------------------
Cl_AAA AAA(/*пин*/2);
Cl_sKeyboard Keyboard;
//------------------------------
void setup() {
  Serial.begin(9600);
  AAA.init();
  Keyboard.init();
}

void loop() {
  mill = millis();
  AAA.run();
  Keyboard.run();
  if (Keyboard.is(event_t::skA))  AAA.write(0);
  if (Keyboard.is(event_t::skB))  AAA.write(10);
  if (Keyboard.is(event_t::skC))  AAA.write(20);
  if (Keyboard.is(event_t::skD))  AAA.write(30);
  if (Keyboard.is(event_t::skE))  AAA.write(40);
  if (Keyboard.is(event_t::skVer))   Serial.println("18/08/2018");
}
/**/

 

/**/
unsigned long mill;
//------------------------------
#include <Servo.h>
class Cl_AAA {
    byte pin;
    char * line;
    Servo _Servo;
    byte val;
  public:
    enum state_t {sFree = 0, sNotYet, sBuzy}; /*состояние свободен,нет еще,занят*/
    bool is(state_t s) {
      return (state == s);
    }
  protected:
    unsigned long past;
    const unsigned long time = 500;
    state_t  state;
    void stand(state_t s) {
      state = s;
      past = mill;
    }
    bool is(state_t s, unsigned long t) {
      return (state == s && mill - past >= t);
    }
  public:
    Cl_AAA(byte p): pin(p) {}
    void init() {
      _Servo.attach(pin);
      write('a');
    }
    void run() {
      if (is(sNotYet, time)) write(line);
      if (is(sBuzy, time)) stand(sFree);
    }
    void write(char c) {
      stand(sBuzy);
      switch (c) {
        case '\0':
          _Servo.write(0);
          break;
        case 'a':
          _Servo.write(10);
          break;
        case 'b':
          _Servo.write(20);
          break;
        case 'c':
          _Servo.write(30);
          break;
        case 'd':
          _Servo.write(40);
          break;
        case 'e':
          _Servo.write(30);
          break;
      }
    }
    void write(const char *a) {
      if  (*a == '\0') {
        stand(sFree);
        return;
      }
      else {
        line = a+1;
        write (*a);
        stand(sNotYet);
      }
    }
};
//--------------------Cl_sKeyboard--------------------------------
/*состояние-нет нажатий/правая/левая/вверх/вниз/влево/выбор*/
enum event_t {skNone = 0, skA, skB, skC, skD,  skE,  skVer};
struct com_t {
  byte com;
  byte event;
};
const byte numCom = 6;
const com_t MAP[numCom] PROGMEM = {
  {'a', event_t::skA}, {'b', event_t::skB}
  , {'c', event_t::skC}, {'d', event_t::skD}
  , {'e', event_t::skE}, {'?', event_t::skVer}
};
class Cl_sKeyboard {
  protected:
    event_t event = event_t::skNone;
  public:
    bool is (event_t e) {
      return e == event;
    }
    Cl_sKeyboard() {}
    void init() {
      Serial.begin(9600);
    }
    void run() {
      event = event_t::skNone;
      if (Serial.available() > 0) {
        byte a = Serial.read();
        for (int i = 0; i < numCom; i++) {
          if (a == pgm_read_byte(&(MAP[i].com))) {
            event = (event_t)pgm_read_byte(&(MAP[i].event));
            break;
          }
        }
      }
    }
};
//------------------------------
Cl_AAA AAA(/*пин*/2);
Cl_sKeyboard Keyboard;
//------------------------------
void setup() {
  Serial.begin(9600);
  AAA.init();
  Keyboard.init();
}

void loop() {
  mill = millis();
  AAA.run();
  Keyboard.run();
  if (Keyboard.is(event_t::skA))  AAA.write("abcde");
  if (Keyboard.is(event_t::skB))  AAA.write("abcdedcba");
  if (Keyboard.is(event_t::skC))  AAA.write('c');
  if (Keyboard.is(event_t::skD))  AAA.write('d');
  if (Keyboard.is(event_t::skE))  AAA.write("abcabc");
  if (Keyboard.is(event_t::skVer))   Serial.println("18/08/2018");
}
/**/

ПС для двух

/**/
unsigned long mill;
//------------------------------
#include <Servo.h>
class Cl_AAA {
    byte pin;
    char * line;
    Servo _Servo;
    byte val;
  public:
    enum state_t {sFree = 0, sNotYet, sBuzy}; /*состояние свободен,нет еще,занят*/
    bool is(state_t s) {
      return (state == s);
    }
  protected:
    unsigned long past;
    const unsigned long time = 500;
    state_t  state;
    void stand(state_t s) {
      state = s;
      past = mill;
    }
    bool is(state_t s, unsigned long t) {
      return (state == s && mill - past >= t);
    }
  public:
    Cl_AAA(byte p): pin(p) {}
    void init() {
      _Servo.attach(pin);
      write('a');
    }
    void run() {
      if (is(sNotYet, time)) write(line);
      if (is(sBuzy, time)) stand(sFree);
    }
    void write(char c) {
      stand(sBuzy);
      switch (c) {
        case '\0':
          _Servo.write(0);
          break;
        case 'a':
          _Servo.write(10);
          break;
        case 'b':
          _Servo.write(20);
          break;
        case 'c':
          _Servo.write(30);
          break;
        case 'd':
          _Servo.write(40);
          break;
        case 'e':
          _Servo.write(30);
          break;
      }
    }
    void write(const char *a) {
      if  (*a == '\0') {
        stand(sFree);
        return;
      }
      else {
        line = a + 1;
        write (*a);
        stand(sNotYet);
      }
    }
};
//--------------------Cl_sKeyboard--------------------------------
/*состояние-нет нажатий/правая/левая/вверх/вниз/влево/выбор*/
enum event_t {skNone = 0, skA, skB, skC, skD,  skE,  skVer};
struct com_t {
  byte com;
  byte event;
};
const byte numCom = 6;
const com_t MAP[numCom] PROGMEM = {
  {'a', event_t::skA}, {'b', event_t::skB}
  , {'c', event_t::skC}, {'d', event_t::skD}
  , {'e', event_t::skE}, {'?', event_t::skVer}
};
class Cl_sKeyboard {
  protected:
    event_t event = event_t::skNone;
  public:
    bool is (event_t e) {
      return e == event;
    }
    Cl_sKeyboard() {}
    void init() {
      Serial.begin(9600);
    }
    void run() {
      event = event_t::skNone;
      if (Serial.available() > 0) {
        byte a = Serial.read();
        for (int i = 0; i < numCom; i++) {
          if (a == pgm_read_byte(&(MAP[i].com))) {
            event = (event_t)pgm_read_byte(&(MAP[i].event));
            break;
          }
        }
      }
    }
};
//------------------------------
Cl_AAA AAA(/*пин*/2);
Cl_AAA BBB(/*пин*/3);
Cl_sKeyboard Keyboard;
//------------------------------
void setup() {
  Serial.begin(9600);
  AAA.init();
  BBB.init();
  Keyboard.init();
}

void loop() {
  mill = millis();
  AAA.run();
  BBB.run();
  Keyboard.run();
  if (Keyboard.is(event_t::skA)) {
    AAA.write("abcde");
    BBB.write("cdeab");
  }
  if (Keyboard.is(event_t::skB))  AAA.write("abcdedcba");
  if (Keyboard.is(event_t::skC))  AAA.write('c');
  if (Keyboard.is(event_t::skD))  AAA.write('d');
  if (Keyboard.is(event_t::skE))  AAA.write("abcabc");
  if (Keyboard.is(event_t::skVer))   Serial.println("18/08/2018");
}
/**/

 

Спасибо Вам ОГРОМНОЕ, qwone!!!  //я пропал ненадолго...пришлось приостановить эксперименты с Ардуино...нужно было уделить время электротехнике...сегодне буду разбирать Ваши скетчи а опробую в работе через 3 дня (заказал ещё 12 серво)...хочу попытаться адаптировать Ваши скетчи для 12 серво...пинов не хватит поэтому попробую подключить по 2 серво на каждый пин управления (питание понятно от доп. источника)...Интересно будет работать или нет...)

Да и по четыре ежели на пин подключать - вращать сервы будет.

....,это цифровые?..потому что у меня сервы с аналоговым управлением MG 996R,,,, т.е. я так понимаю что если 2 или больше на один пин то это параллельное включение значит сопротивление падает в 2 и более раз а ток растёт в 2 и более раз...ну если два это ещё может и не смартельно НО ЧЕТЫРЕ???

Почему вы думаете, что две - не смертельно, а четыре - перебор? Произвели расчет силы тока, потребляемые сервами от управляющего пина Ардуины?

Неправильно, сигнал ШИМ (PWM) тоже цифровой. Аналоговых выходов (ЦАП) в ардуине нет вообще, есть только аналоговые входы (АЦП).

я имел ввиду что согласно тому что выходное сопротивление относительно управляющего пина значительно падает то в принципе и две сервы это парегрузка по току которую ВОЗМОЖНО плата выдержит а чктыре это сомнительно очень...

ну ШИМ это не совсем цифровой сигнал т.к. по амплитуде он может быть любым в принципе... а цифровой больше логической единицы (не знаю какому напряжению для ардуино это соответствует) быть не может...

Ну так то да, есть аналоговый ШИМ и цифровой ШИМ. Но в ардуине именно цифровой ШИМ, напряжение всегда одинаковое и равняется логическому нулю или единице. Ардуина на физическом уровне не может менять выходное напряжение, кроме как 0В (GND) и 5В (или 3.3В) (VCC).

амплитуда у ШИМ, не поверишь - та же логическая единица (то бишь +5В на ардуине, а не любая), а скважность - меняется, поэтому действующее значение - разное.  

... честгно говоря не верится что компараторы на ардуино какие то другие и высокий уровень у них 5 Вольт...возможно дальше сигнал усиливается до 5 Вольт на выходе... про скважность всё известно но выходное сопротивление должно влиять на амплитуду сигнала независимо от скважности импульсов...)

...ага значит выходное сопротивление цифровых пинов бесконечно большое относительно входа со стороны выхода..интересно...какую же нагрузку выдержит цифровой пин?)...по току я так слышал 40 mA...значит измерив сопротивление нагрузки можем посчитать допустимую можность...так как именно мощность нагрузки определяет ток нагрузки а значит и ток пина...

40мА нагрузочная способность пина, но не более 200 мА на весь кристалл.

Ты б хоть почитал чонить штоли, для интереса. 

...я мног чего читал и продолжаю читать ...а посему вопрос остаётся открытым : сколько серво выдержит цифровой пин?)))

Ответ остается тот же - без ключа/реле/оптрона - ни одной. 

А если по времени, то секунды 3 до воспарения белого дыма. 

...Вы неправильно поняли... там выше по теме видно что имеется ввиду управление сервой (естественно при доп. питании)...там человек писал что они управляли с одного пина 4мя серво...вот в чём вопрос...

Дак а проблема то в чем?  С одного пина можно управлять не только 4-мя сервами, но и даже, наерна, всеми турбинами Братской ГЭС, при желании. 

...да можно хоть двумя ГЭС управлять через дополнительные силовые цепи или как вы правильно писали реле, оптрон...и т.д. ...НО у нашей сервы есть плата управления на которую поступает наш управляющий сигнал определённой амплитуды...а когда мы добавляем ещё одну серву амплитуда неминуемо изменяется т.к. падает сопротивление  это ведёт к росту тока...вот в чём вопрос

Так вам что надо-то? Если больше одной сервы крутить и еще мигать светодиодом - ставьте доп. ключи для раскачки сигнала. Вы какого-то фокуса от ардуины или от нас ждете?

Только я не понимаю - куда присобачить две и более сервы, крутящиеся в одном ритме.

....есть у меня один для всех далеко не новый но прикольный и первый для меня проэктик (собственно на нём и начал изучать ардуино)... пока не сделаю всё чтобы работало не хочу говорить что это...а потом обязательно покажу обещаю...)

сейчас вот разбираюсь со скетчами qwonа...реально у него светлая голова...завидую... )

насчёт ключей ...просто не хочется схему раздувать и делать дороже...попробую по 2 серво на пин...)

Замерьте ток потребления на линии управления одной сервы, поделите предельные 40мА на этот ток .. получите ответ на свой вопрос: сколькими сервами сможет управлять камень по одной ноге. (* я правла нифига не знаю зачем надо синхронно управлять несколькими сервами .. может поставить одну, но помощней? *)

Сдается мне, что логика управления сервой .. всё на том же КМОП, и токи потребления там сотые доли наноампера .. ну может с 0.5мА в импульсе перезаряда входной емкости ..

...что мнтересно я при расчёте исходя из сопротивления управляющего конца получил именно эту цифру 0,5 mA...)..но мне она кажется не совсем верной..)

насчёт прямого измерения тока управления......(кстсти Вы не знаете где найти схему платы управления сервы MG 996R ??) ....прямым измерением наверное можно  ...если задать угол поворота 180 град. то скважность будет наибольшей ...а значит и действующее значение будет наибольшим...)

Вот пусть у нас есть океанский лайнер...

Одного пассажира он должен выдерживать.

Два пассажира - это, в принципе, уже перегрузка.

Ну а 4 - почти наверняка потонет.

 

PS. Ну зарегистрируйтесь на каком-нибудь локальном форуме, найдите там раздел для тем ни о чем, и постите туда свои измышления. А здесь как-то принято оперировать конкретными цифрами и фактами.

Измерять нужно не действующее значение, а амплитудное.

...это понятно но мультиметром можно только действующее или правильнее сказать среднее значение измерить (т.к. для синусоиды эти два значения будут ПОЧТИ совпадать а для прямоугольных импульсов коими является ШИМ деяствующее будет отличаться от среднего...только спец. RMS-мультиметр может измерить...) тут без осциллографа не обойтись...или просто разделить среднее на 0,64 и получить амплитудное...или умножить среднеквадратичное(действующее) на корень из 2х и тоже получить  максимальное))(но это тоже только для синусоиды)

... РАБОТАЕТ!!!...собрал наконец-то свою конструкцию включил все 12 серво причём воскмь из них параллельно на 4 управляющих пина... и...всё очень весело крутится....токи управления пока не измерял....осциллограф есть но руки до него не доходят (но обязательно померяю)....и вот теперь пришло время опробовать скетчи qwona )

---