Arduino.ru

что за задержку?

Пусковая задержка. Когда включилась ардуино, то нужно подождать программе 2 секунды чтобы бензонасос успел набрать давление в системе,после на все 4 пина инжекторов подать в прерывестом режиме примерно по 20 милисекунд в течении 2 секунд.Так как шторка датчика холла который определяет ВМТ может проити его,и нужно будет сделать два холостых оборота каленвала чтобы он дал команду на выполнение цикла.Двигателю хватит этого чтоб завестись и не мучить стартер.

Похоже так.

/*
  ардуино пин A0 <--> средний вывод потенциометра
  ардуино пин 2 <--> датчик холла 1 запуск инжектора на каждый горшок
  ардуино пин 3 <--> датчик холла 2 установка 1 горшка
  ардуино пин 6 <--> инжектор 1
  ардуино пин 7 <--> инжектор 2
  ардуино пин 8 <--> инжектор 3
  ардуино пин 9 <--> инжектор 4
  Запуск системы через 2 секунды.
*/
uint32_t micro, mill; // переменные для micros() и millis()
//------------Cl_Inject------------------------------
// класс инжектор
class Cl_Inject {
    const byte pin;// нога
    const bool inv;// инверсия выхода
    uint32_t *pnt_time1, *pnt_time2; // указатели на время задержки и времени впрыска
    uint32_t time1, time2; // время задержки и времени впрыска
    byte stat = 0; //2(1этап)/1(2этап)/ 0 стоп
    uint32_t past;
  public:
    Cl_Inject(byte _pin, bool _inv, uint32_t *_pnt_time1, uint32_t *_pnt_time2)
      :        pin(_pin), inv(_inv),   pnt_time1(_pnt_time1),     pnt_time2(_pnt_time2) {}
    void setup() {
      pinMode(pin, OUTPUT);
      stat = 0;
      digitalWrite(pin, inv); // выключить инжектор
    }
    void loop() {
      if (stat == 2 && micro - past >= time1) { // если подошло время включить инжектор
        stat = 1;
        past = micro;
        digitalWrite(pin, !inv); // то включить инжектор
      }
      if (stat == 1 && micro - past >= time2) { // если подошло время выключить инжектор
        stat = 0;
        digitalWrite(pin, inv); // то выключить инжектор
      }
    }
    void inject() {
      time1 = *pnt_time1;
      time2 = *pnt_time2;
      stat = 2;
      past = micro;
    }
};
//--------------------Cl_Potentiometer---------------------------------------------
// класс потенциометр
class Cl_Potentiometer {
    const byte _pin;
    uint32_t *const _pnt;// указатель переменную которая меняет значение по положению ручки потенциометра
    uint32_t past = 0;
  public:
    Cl_Potentiometer(byte pin, uint32_t *pnt): _pin(pin), _pnt(pnt) {}
    void setup() {
      *_pnt = 10000ul / 1023 * analogRead(_pin); // значение впрыска меняется от 0 до 10 000 микросек
    }
    void loop() {
      if (mill - past > 100) {
        *_pnt = 10000ul / 1023 * analogRead(_pin);
        past = mill;
      }
    }
};
//-----------------Cl_Hall---------------------------------
// класс датчика Холла
class Cl_Hall {
    const byte pin;// нога
    const bool inv;// инверсия выхода
    void (*Do)();// указатель на обработчик
    bool Hall, Hall_old;
  public:
    Cl_Hall(byte _pin, bool _inv, void (*_Do)())
      :      pin(_pin), inv(_inv),    Do(_Do)  {}
    void setup() {
      pinMode(pin, INPUT);
      Hall_old = digitalRead(pin)^inv;
    }
    void loop() {
      Hall = digitalRead(pin)^inv;
      if (Hall && !Hall_old ) {
        Hall_old = 1;
        Do();
      }
      if (!Hall && Hall_old ) {
        Hall_old = 0;
      }
    }
};
//----------Cl_Hall2_Inject4-----------------------------------------
// класс из 2-x датчиков Холла и 4-x инжекторов
class Cl_Hall2_Inject4 {
    Cl_Hall Hall_1, Hall_2;
    Cl_Inject Inject1, Inject2, Inject3, Inject4;
    byte num = 0; // номер инжектора для текущей инжекции
    bool stat = 0; // 0 отключен / 1 работает
  public:
    Cl_Hall2_Inject4(byte _pin1, byte _pin2, bool _invH, void (*_Do1)(), void (*_Do2)(),
                     byte _pin3, byte _pin4, byte _pin5, byte _pin6, bool _invI, uint32_t *_pnt_time1, uint32_t *_pnt_time2)
      : Hall_1(_pin1, _invH, _Do1), Hall_2(_pin2, _invH, _Do2),
        Inject1(_pin3, _invI, _pnt_time1, _pnt_time2), Inject2(_pin4, _invI, _pnt_time1, _pnt_time2),
        Inject3(_pin5, _invI, _pnt_time1, _pnt_time2), Inject4(_pin6, _invI, _pnt_time1, _pnt_time2) {}
    void setup() {
      Hall_1. setup();
      Hall_2. setup();
      Inject1. setup();
      Inject2. setup();
      Inject3. setup();
      Inject4. setup();
    }
    void loop() {
      if (!stat) return;
      Hall_1. loop();
      Hall_2. loop();
      Inject1. loop();
      Inject2. loop();
      Inject3. loop();
      Inject4. loop();
    }
    void inject() {
      switch (num) {
        case 0:
          Inject1.inject();
          break;
        case 1:
          Inject2.inject();
          break;
        case 2:
          Inject3.inject();
          break;
        case 3:
          Inject4.inject();
          break;
      }
      ++num; if (num > 3)num = 0;
    }
    void clear() {
      num = 0;
    }
    void start() {// включть работу
      stat = 1;
    }
};
//----------------Cl_Delay-------------------------------
// класс задержка запуск системы через некоторое время
class Cl_Delay {
    uint32_t time;
    void (*Do)();
    bool stat = 0; // 0 ждем /0->1 вызов обработчика / 1 все
    uint32_t past = 0;
  public:
    Cl_Delay(uint32_t _time, void (*_Do)())
      : time(_time), Do(_Do) {}
    void loop() {
      if (!stat && mill - past >= time) {
        stat = 1;
        (*Do)();
      }
    }
};
//--------------компоновка----------------------------
uint32_t time1 = 1000; // время задержки впрыска ,микросек
uint32_t time2 = 6000; // время  впрыска  ,микросек
Cl_Potentiometer Potentiometer(/*пин потенциометра*/A0,/*переменая*/&time2);// подключить потенциометр
void Do_Inject();
void Do_Clear();
Cl_Hall2_Inject4  Hall2_Inject4(/*нога датчика*/2,/*нога датчика*/3,/*инвесия ввода*/0,/*обработчик1*/Do_Inject,/*обработчик2*/Do_Clear,
    /*нога инжектора1*/6,/*нога инжектора2*/7,/*нога инжектора3*/8,/*нога инжектора4*/9,/*инвесия вывода*/0,/**/&time1,/**/&time2);
void Do_Inject() {
  Hall2_Inject4.inject();
}
void Do_Clear() {
  Hall2_Inject4.clear();
}
void Do_Delay() {
  Hall2_Inject4.start();
}
Cl_Delay Delay(/*задержка 2 сек*/2000,/*обработчик*/Do_Delay);
//-------------main()-----------------------------
void setup() {
  Potentiometer.setup();
  Hall2_Inject4.setup();
}
void loop() {
  micro = micros();
  mill = millis();
  Potentiometer.loop();
  Hall2_Inject4.loop();
  Delay.loop();
}
/*Скетч использует 2186 байт (6%) памяти устройства. Всего доступно 32256 байт.
  Глобальные переменные используют 133 байт (6%) динамической памяти, оставляя 1915 байт для локальных переменных. Максимум: 2048 байт
*/

Задержка программы на 2 секунды работает, только 4 инжектора одновременно не включаются.Сразу рабочий цикл начинается.

Ну да . Вам надо что бы еще 4 инжектора работали по датчику холла? И сколько? с какая длительность инжекции?

Можно по холлу сделать 200 милисекунд. 

Если так будет проще можно сделать как блинк по 20 милисекунд.на 2 секунды без холла

/*
  ардуино пин A0 <--> средний вывод потенциометра
  ардуино пин 2 <--> датчик холла 1 запуск инжектора на каждый горшок
  ардуино пин 3 <--> датчик холла 2 установка 1 горшка
  ардуино пин 6 <--> инжектор 1
  ардуино пин 7 <--> инжектор 2
  ардуино пин 8 <--> инжектор 3
  ардуино пин 9 <--> инжектор 4
  Запуск системы через 2 секунды.
   подготовка еще 0,2 секунды - все инжекторы работают 
*/
uint32_t micro, mill; // переменные для micros() и millis()
//------------Cl_Inject------------------------------
// класс инжектор
class Cl_Inject {
    const byte pin;// нога
    const bool inv;// инверсия выхода
    uint32_t *pnt_time1, *pnt_time2; // указатели на время задержки и времени впрыска
    uint32_t time1, time2; // время задержки и времени впрыска
    byte stat = 0; //2(1этап)/1(2этап)/ 0 стоп
    uint32_t past;
  public:
    Cl_Inject(byte _pin, bool _inv, uint32_t *_pnt_time1, uint32_t *_pnt_time2)
      :        pin(_pin), inv(_inv),   pnt_time1(_pnt_time1),     pnt_time2(_pnt_time2) {}
    void setup() {
      pinMode(pin, OUTPUT);
      stat = 0;
      digitalWrite(pin, inv); // выключить инжектор
    }
    void loop() {
      if (stat == 2 && micro - past >= time1) { // если подошло время включить инжектор
        stat = 1;
        past = micro;
        digitalWrite(pin, !inv); // то включить инжектор
      }
      if (stat == 1 && micro - past >= time2) { // если подошло время выключить инжектор
        stat = 0;
        digitalWrite(pin, inv); // то выключить инжектор
      }
    }
    void inject() {
      time1 = *pnt_time1;
      time2 = *pnt_time2;
      stat = 2;
      past = micro;
    }
};
//--------------------Cl_Potentiometer---------------------------------------------
// класс потенциометр
class Cl_Potentiometer {
    const byte _pin;
    uint32_t *const _pnt;// указатель переменную которая меняет значение по положению ручки потенциометра
    uint32_t past = 0;
  public:
    Cl_Potentiometer(byte pin, uint32_t *pnt): _pin(pin), _pnt(pnt) {}
    void setup() {
      *_pnt = 10000ul / 1023 * analogRead(_pin); // значение впрыска меняется от 0 до 10 000 микросек
    }
    void loop() {
      if (mill - past > 100) {
        *_pnt = 10000ul / 1023 * analogRead(_pin);
        past = mill;
      }
    }
};
//-----------------Cl_Hall---------------------------------
// класс датчика Холла
class Cl_Hall {
    const byte pin;// нога
    const bool inv;// инверсия выхода
    void (*Do)();// указатель на обработчик
    bool Hall, Hall_old;
  public:
    Cl_Hall(byte _pin, bool _inv, void (*_Do)())
      :      pin(_pin), inv(_inv),    Do(_Do)  {}
    void setup() {
      pinMode(pin, INPUT);
      Hall_old = digitalRead(pin)^inv;
    }
    void loop() {
      Hall = digitalRead(pin)^inv;
      if (Hall && !Hall_old ) {
        Hall_old = 1;
        Do();
      }
      if (!Hall && Hall_old ) {
        Hall_old = 0;
      }
    }
};
//----------Cl_Hall2_Inject4-----------------------------------------
// класс из 2-x датчиков Холла и 4-x инжекторов
class Cl_Hall2_Inject4 {
    Cl_Hall Hall_1, Hall_2;
    Cl_Inject Inject1, Inject2, Inject3, Inject4;
    byte num = 0; // номер инжектора для текущей инжекции
    byte stat = 0; // 0 отключен / 1 подготовка / 2 работа
  public:
    Cl_Hall2_Inject4(byte _pin1, byte _pin2, bool _invH, void (*_Do1)(), void (*_Do2)(),
                     byte _pin3, byte _pin4, byte _pin5, byte _pin6, bool _invI, uint32_t *_pnt_time1, uint32_t *_pnt_time2)
      : Hall_1(_pin1, _invH, _Do1), Hall_2(_pin2, _invH, _Do2),
        Inject1(_pin3, _invI, _pnt_time1, _pnt_time2), Inject2(_pin4, _invI, _pnt_time1, _pnt_time2),
        Inject3(_pin5, _invI, _pnt_time1, _pnt_time2), Inject4(_pin6, _invI, _pnt_time1, _pnt_time2) {}
    void setup() {
      Hall_1. setup();
      Hall_2. setup();
      Inject1. setup();
      Inject2. setup();
      Inject3. setup();
      Inject4. setup();
    }
    void loop() {
      if (stat == 0) return;
      Hall_1. loop();
      Hall_2. loop();
      Inject1. loop();
      Inject2. loop();
      Inject3. loop();
      Inject4. loop();
    }
    void inject() {
      if (stat == 0) return;
      else if ( stat = 1) {
        Inject1.inject();
        Inject2.inject();
        Inject3.inject();
        Inject4.inject();
      }
      else {
        switch (num) {
          case 0:
            Inject1.inject();
            break;
          case 1:
            Inject2.inject();
            break;
          case 2:
            Inject3.inject();
            break;
          case 3:
            Inject4.inject();
            break;
        }
        ++num; if (num > 3)num = 0;
      }
    }
    void clear() {
      num = 0;
    }
    void preparation() {// включить подготовку
      stat = 1;
    }
    void work() {// включить работу
      stat = 2;
    }
};
//----------------Cl_Delay-------------------------------
// класс задержка запуск системы через некоторое время
class Cl_Delay {
    uint32_t time1, time2;
    void (*Do1)(), (*Do2)();
    byte stat = 0; // 0 - пауза / 1 - подготовка /2 - работа
    uint32_t past = 0;
  public:
    Cl_Delay(uint32_t _time1, void (*_Do1)(), uint32_t _time2, void (*_Do2)())
      : time1(_time1), Do1(_Do1), time2(_time2), Do2(_Do2) {}
    void loop() {
      if (stat == 0 && mill - past >= time1) {
        past = mill;
        stat = 1;
        (*Do1)();
      }
      if (stat == 1 && mill - past >= time2) {
        past = mill;
        stat = 2;
        (*Do2)();
      }
    }
};
//--------------компоновка----------------------------
uint32_t time1 = 1000; // время задержки впрыска ,микросек
uint32_t time2 = 6000; // время  впрыска  ,микросек
Cl_Potentiometer Potentiometer(/*пин потенциометра*/A0,/*переменая*/&time2);// подключить потенциометр
void Do_Inject();
void Do_Clear();
Cl_Hall2_Inject4  Hall2_Inject4(/*нога датчика*/2,/*нога датчика*/3,/*инвесия ввода*/0,/*обработчик1*/Do_Inject,/*обработчик2*/Do_Clear,
    /*нога инжектора1*/6,/*нога инжектора2*/7,/*нога инжектора3*/8,/*нога инжектора4*/9,/*инвесия вывода*/0,/**/&time1,/**/&time2);
void Do_Inject() {
  Hall2_Inject4.inject();
}
void Do_Clear() {
  Hall2_Inject4.clear();
}
void Do1_Delay() {
  Hall2_Inject4.preparation();
}
void Do2_Delay() {
  Hall2_Inject4.work();
}
Cl_Delay Delay(
  /*задержка 2 сек*/2000,                           // пауза
  /*обработчик*/Do1_Delay, /*задержка 0,2 сек*/200, // подготовка
  /*обработчик*/Do2_Delay);                         // работа
//-------------main()-----------------------------
void setup() {
  Potentiometer.setup();
  Hall2_Inject4.setup();
}
void loop() {
  micro = micros();
  mill = millis();
  Potentiometer.loop();
  Hall2_Inject4.loop();
  Delay.loop();
}
/*Скетч использует 2330 байт (7%) памяти устройства. Всего доступно 32256 байт.
  Глобальные переменные используют 139 байт (6%) динамической памяти, оставляя 1909 байт для локальных переменных. Максимум: 2048 байт.
*/

Теперь они застряли в своем цикле и не переключаются на основной чтоб работать по одному одному

 можно при загрузке камня задать 200 милисекунд в переменную "А" до того момента как датчик ВМТ не подставит переменую " таим 2"

Ну здесь мой зевок строка 123       else if ( stat == 1) {  // <------  Классический зевок в Си = вместо ==

/*
  ардуино пин A0 <--> средний вывод потенциометра
  ардуино пин 2 <--> датчик холла 1 запуск инжектора на каждый горшок
  ардуино пин 3 <--> датчик холла 2 установка 1 горшка
  ардуино пин 6 <--> инжектор 1
  ардуино пин 7 <--> инжектор 2
  ардуино пин 8 <--> инжектор 3
  ардуино пин 9 <--> инжектор 4
  Запуск системы через 2 секунды.
   подготовка еще 0,2 секунды - все инжекторы работают
*/
uint32_t micro, mill; // переменные для micros() и millis()
//------------Cl_Inject------------------------------
// класс инжектор
class Cl_Inject {
    const byte pin;// нога
    const bool inv;// инверсия выхода
    uint32_t *pnt_time1, *pnt_time2; // указатели на время задержки и времени впрыска
    uint32_t time1, time2; // время задержки и времени впрыска
    byte stat = 0; //2(1этап)/1(2этап)/ 0 стоп
    uint32_t past;
  public:
    Cl_Inject(byte _pin, bool _inv, uint32_t *_pnt_time1, uint32_t *_pnt_time2)
      :        pin(_pin), inv(_inv),   pnt_time1(_pnt_time1),     pnt_time2(_pnt_time2) {}
    void setup() {
      pinMode(pin, OUTPUT);
      stat = 0;
      digitalWrite(pin, inv); // выключить инжектор
    }
    void loop() {
      if (stat == 2 && micro - past >= time1) { // если подошло время включить инжектор
        stat = 1;
        past = micro;
        digitalWrite(pin, !inv); // то включить инжектор
      }
      if (stat == 1 && micro - past >= time2) { // если подошло время выключить инжектор
        stat = 0;
        digitalWrite(pin, inv); // то выключить инжектор
      }
    }
    void inject() {
      time1 = *pnt_time1;
      time2 = *pnt_time2;
      stat = 2;
      past = micro;
    }
};
//--------------------Cl_Potentiometer---------------------------------------------
// класс потенциометр
class Cl_Potentiometer {
    const byte _pin;
    uint32_t *const _pnt;// указатель переменную которая меняет значение по положению ручки потенциометра
    uint32_t past = 0;
  public:
    Cl_Potentiometer(byte pin, uint32_t *pnt): _pin(pin), _pnt(pnt) {}
    void setup() {
      *_pnt = 10000ul / 1023 * analogRead(_pin); // значение впрыска меняется от 0 до 10 000 микросек
    }
    void loop() {
      if (mill - past > 100) {
        *_pnt = 10000ul / 1023 * analogRead(_pin);
        past = mill;
      }
    }
};
//-----------------Cl_Hall---------------------------------
// класс датчика Холла
class Cl_Hall {
    const byte pin;// нога
    const bool inv;// инверсия выхода
    void (*Do)();// указатель на обработчик
    bool Hall, Hall_old;
  public:
    Cl_Hall(byte _pin, bool _inv, void (*_Do)())
      :      pin(_pin), inv(_inv),    Do(_Do)  {}
    void setup() {
      pinMode(pin, INPUT);
      Hall_old = digitalRead(pin)^inv;
    }
    void loop() {
      Hall = digitalRead(pin)^inv;
      if (Hall && !Hall_old ) {
        Hall_old = 1;
        Do();
      }
      if (!Hall && Hall_old ) {
        Hall_old = 0;
      }
    }
};
//----------Cl_Hall2_Inject4-----------------------------------------
// класс из 2-x датчиков Холла и 4-x инжекторов
class Cl_Hall2_Inject4 {
    Cl_Hall Hall_1, Hall_2;
    Cl_Inject Inject1, Inject2, Inject3, Inject4;
    byte num = 0; // номер инжектора для текущей инжекции
    byte stat = 0; // 0 отключен / 1 подготовка / 2 работа
  public:
    Cl_Hall2_Inject4(byte _pin1, byte _pin2, bool _invH, void (*_Do1)(), void (*_Do2)(),
                     byte _pin3, byte _pin4, byte _pin5, byte _pin6, bool _invI, uint32_t *_pnt_time1, uint32_t *_pnt_time2)
      : Hall_1(_pin1, _invH, _Do1), Hall_2(_pin2, _invH, _Do2),
        Inject1(_pin3, _invI, _pnt_time1, _pnt_time2), Inject2(_pin4, _invI, _pnt_time1, _pnt_time2),
        Inject3(_pin5, _invI, _pnt_time1, _pnt_time2), Inject4(_pin6, _invI, _pnt_time1, _pnt_time2) {}
    void setup() {
      Hall_1. setup();
      Hall_2. setup();
      Inject1. setup();
      Inject2. setup();
      Inject3. setup();
      Inject4. setup();
    }
    void loop() {
      if (stat == 0) return;
      Hall_1. loop();
      Hall_2. loop();
      Inject1. loop();
      Inject2. loop();
      Inject3. loop();
      Inject4. loop();
    }
    void inject() {
      if (stat == 0) return;
      else if ( stat == 1) {  // <------  Классический зевок в Си = вместо ==
        Inject1.inject();
        Inject2.inject();
        Inject3.inject();
        Inject4.inject();
      }
      else {
        switch (num) {
          case 0:
            Inject1.inject();
            break;
          case 1:
            Inject2.inject();
            break;
          case 2:
            Inject3.inject();
            break;
          case 3:
            Inject4.inject();
            break;
        }
        ++num; if (num > 3)num = 0;
      }
    }
    void clear() {
      num = 0;
    }
    void preparation() {// включить подготовку
      stat = 1;
    }
    void work() {// включить работу
      stat = 2;
    }
};
//----------------Cl_Delay-------------------------------
// класс задержка запуск системы через некоторое время
class Cl_Delay {
    uint32_t time1, time2;
    void (*Do1)(), (*Do2)();
    byte stat = 0; // 0 - пауза / 1 - подготовка /2 - работа
    uint32_t past = 0;
  public:
    Cl_Delay(uint32_t _time1, void (*_Do1)(), uint32_t _time2, void (*_Do2)())
      : time1(_time1), Do1(_Do1), time2(_time2), Do2(_Do2) {}
    void loop() {
      if (stat == 0 && mill - past >= time1) {
        past = mill;
        stat = 1;
        (*Do1)();
      }
      if (stat == 1 && mill - past >= time2) {
        past = mill;
        stat = 2;
        (*Do2)();
      }
    }
};
//--------------компоновка----------------------------
uint32_t time1 = 1000; // время задержки впрыска ,микросек
uint32_t time2 = 6000; // время  впрыска  ,микросек
Cl_Potentiometer Potentiometer(/*пин потенциометра*/A0,/*переменая*/&time2);// подключить потенциометр
void Do_Inject();
void Do_Clear();
Cl_Hall2_Inject4  Hall2_Inject4(/*нога датчика*/2,/*нога датчика*/3,/*инвесия ввода*/0,/*обработчик1*/Do_Inject,/*обработчик2*/Do_Clear,
    /*нога инжектора1*/6,/*нога инжектора2*/7,/*нога инжектора3*/8,/*нога инжектора4*/9,/*инвесия вывода*/0,/**/&time1,/**/&time2);
void Do_Inject() {
  Hall2_Inject4.inject();
}
void Do_Clear() {
  Hall2_Inject4.clear();
}
void Do1_Delay() {
  Hall2_Inject4.preparation();
}
void Do2_Delay() {
  Hall2_Inject4.work();
}
Cl_Delay Delay(
  /*задержка 2 сек*/2000,                           // пауза
  /*обработчик*/Do1_Delay, /*задержка 0,2 сек*/200, // подготовка
  /*обработчик*/Do2_Delay);                         // работа
//-------------main()-----------------------------
void setup() {
  Potentiometer.setup();
  Hall2_Inject4.setup();
}
void loop() {
  micro = micros();
  mill = millis();
  Potentiometer.loop();
  Hall2_Inject4.loop();
  Delay.loop();
}
/*Скетч использует 2330 байт (7%) памяти устройства. Всего доступно 32256 байт.
  Глобальные переменные используют 139 байт (6%) динамической памяти, оставляя 1909 байт для локальных переменных. Максимум: 2048 байт.
*/

Не нето теперь 4 неработает ,только по одному.

Попробуйте так . А вообще растяните время подготовки с 0,2 до 2 секунд

/*
  ардуино пин A0 <--> средний вывод потенциометра
  ардуино пин 2 <--> датчик холла 1 запуск инжектора на каждый горшок
  ардуино пин 3 <--> датчик холла 2 установка 1 горшка
  ардуино пин 6 <--> инжектор 1
  ардуино пин 7 <--> инжектор 2
  ардуино пин 8 <--> инжектор 3
  ардуино пин 9 <--> инжектор 4
  Запуск системы через 2 секунды.
   подготовка еще 0,2 секунды - все инжекторы работают
*/
uint32_t micro, mill; // переменные для micros() и millis()
//------------Cl_Inject------------------------------
// класс инжектор
class Cl_Inject {
    const byte pin;// нога
    const bool inv;// инверсия выхода
    uint32_t *pnt_time1, *pnt_time2; // указатели на время задержки и времени впрыска
    uint32_t time1, time2; // время задержки и времени впрыска
    byte stat = 0; //2(1этап)/1(2этап)/ 0 стоп
    uint32_t past;
  public:
    Cl_Inject(byte _pin, bool _inv, uint32_t *_pnt_time1, uint32_t *_pnt_time2)
      :        pin(_pin), inv(_inv),   pnt_time1(_pnt_time1),     pnt_time2(_pnt_time2) {}
    void setup() {
      pinMode(pin, OUTPUT);
      stat = 0;
      digitalWrite(pin, inv); // выключить инжектор
    }
    void loop() {
      if (stat == 2 && micro - past >= time1) { // если подошло время включить инжектор
        stat = 1;
        past = micro;
        digitalWrite(pin, !inv); // то включить инжектор
      }
      if (stat == 1 && micro - past >= time2) { // если подошло время выключить инжектор
        stat = 0;
        digitalWrite(pin, inv); // то выключить инжектор
      }
    }
    void inject() {
      time1 = *pnt_time1;
      time2 = *pnt_time2;
      stat = 2;
      past = micro;
    }
};
//--------------------Cl_Potentiometer---------------------------------------------
// класс потенциометр
class Cl_Potentiometer {
    const byte _pin;
    uint32_t *const _pnt;// указатель переменную которая меняет значение по положению ручки потенциометра
    uint32_t past = 0;
  public:
    Cl_Potentiometer(byte pin, uint32_t *pnt): _pin(pin), _pnt(pnt) {}
    void setup() {
      *_pnt = 10000ul / 1023 * analogRead(_pin); // значение впрыска меняется от 0 до 10 000 микросек
    }
    void loop() {
      if (mill - past > 100) {
        *_pnt = 10000ul / 1023 * analogRead(_pin);
        past = mill;
      }
    }
};
//-----------------Cl_Hall---------------------------------
// класс датчика Холла
class Cl_Hall {
    const byte pin;// нога
    const bool inv;// инверсия выхода
    void (*Do)();// указатель на обработчик
    bool Hall, Hall_old;
  public:
    Cl_Hall(byte _pin, bool _inv, void (*_Do)())
      :      pin(_pin), inv(_inv),    Do(_Do)  {}
    void setup() {
      pinMode(pin, INPUT);
      Hall_old = digitalRead(pin)^inv;
    }
    void loop() {
      Hall = digitalRead(pin)^inv;
      if (Hall && !Hall_old ) {
        Hall_old = 1;
        Do();
      }
      if (!Hall && Hall_old ) {
        Hall_old = 0;
      }
    }
};
//----------Cl_Hall2_Inject4-----------------------------------------
// класс из 2-x датчиков Холла и 4-x инжекторов
class Cl_Hall2_Inject4 {
    Cl_Hall Hall_1, Hall_2;
    Cl_Inject Inject1, Inject2, Inject3, Inject4;
    byte num = 0; // номер инжектора для текущей инжекции
    byte stat = 0; // 0 отключен / 1 подготовка / 2 работа
  public:
    Cl_Hall2_Inject4(byte _pin1, byte _pin2, bool _invH, void (*_Do1)(), void (*_Do2)(),
                     byte _pin3, byte _pin4, byte _pin5, byte _pin6, bool _invI, uint32_t *_pnt_time1, uint32_t *_pnt_time2)
      : Hall_1(_pin1, _invH, _Do1), Hall_2(_pin2, _invH, _Do2),
        Inject1(_pin3, _invI, _pnt_time1, _pnt_time2), Inject2(_pin4, _invI, _pnt_time1, _pnt_time2),
        Inject3(_pin5, _invI, _pnt_time1, _pnt_time2), Inject4(_pin6, _invI, _pnt_time1, _pnt_time2) {}
    void setup() {
      Hall_1. setup();
      Hall_2. setup();
      Inject1. setup();
      Inject2. setup();
      Inject3. setup();
      Inject4. setup();
    }
    void loop() {
      if (stat == 0) return;
      Hall_1. loop();
      Hall_2. loop();
      Inject1. loop();
      Inject2. loop();
      Inject3. loop();
      Inject4. loop();
    }
    void inject() {
      if (stat == 0) return;
      if (stat == 1) {
        Inject1.inject();
        Inject2.inject();
        Inject3.inject();
        Inject4.inject();
      }
      if (stat == 2) {
        switch (num) {
          case 0:
            Inject1.inject();
            break;
          case 1:
            Inject2.inject();
            break;
          case 2:
            Inject3.inject();
            break;
          case 3:
            Inject4.inject();
            break;
        }
        ++num; if (num > 3)num = 0;
      }
    }
    void clear() {
      num = 0;
    }
    void preparation() {// включить подготовку
      stat = 1;
    }
    void work() {// включить работу
      stat = 2;
    }
};
//----------------Cl_Delay-------------------------------
// класс задержка запуск системы через некоторое время
class Cl_Delay {
    uint32_t time1, time2;
    void (*Do1)(), (*Do2)();
    byte stat = 0; // 0 - пауза / 1 - подготовка /2 - работа
    uint32_t past = 0;
  public:
    Cl_Delay(uint32_t _time1, void (*_Do1)(), uint32_t _time2, void (*_Do2)())
      : time1(_time1), Do1(_Do1), time2(_time2), Do2(_Do2) {}
    void loop() {
      if (stat == 0 && mill - past >= time1) {
        past = mill;
        stat = 1;
        (*Do1)();
      }
      if (stat == 1 && mill - past >= time2) {
        past = mill;
        stat = 2;
        (*Do2)();
      }
    }
};
//--------------компоновка----------------------------
uint32_t time1 = 1000; // время задержки впрыска ,микросек
uint32_t time2 = 6000; // время  впрыска  ,микросек
Cl_Potentiometer Potentiometer(/*пин потенциометра*/A0,/*переменая*/&time2);// подключить потенциометр
void Do_Inject();
void Do_Clear();
Cl_Hall2_Inject4  Hall2_Inject4(/*нога датчика*/2,/*нога датчика*/3,/*инвесия ввода*/0,/*обработчик1*/Do_Inject,/*обработчик2*/Do_Clear,
    /*нога инжектора1*/6,/*нога инжектора2*/7,/*нога инжектора3*/8,/*нога инжектора4*/9,/*инвесия вывода*/0,/**/&time1,/**/&time2);
void Do_Inject() {
  Hall2_Inject4.inject();
}
void Do_Clear() {
  Hall2_Inject4.clear();
}
void Do1_Delay() {
  Hall2_Inject4.preparation();
}
void Do2_Delay() {
  Hall2_Inject4.work();
}
Cl_Delay Delay(
  /*задержка 2 сек*/2000,                           // пауза
  /*обработчик*/Do1_Delay, /*задержка 0,2 сек*/200, // подготовка
  /*обработчик*/Do2_Delay);                         // работа
//-------------main()-----------------------------
void setup() {
  Potentiometer.setup();
  Hall2_Inject4.setup();
}
void loop() {
  micro = micros();
  mill = millis();
  Potentiometer.loop();
  Hall2_Inject4.loop();
  Delay.loop();
}
/*Скетч использует 2400 байт (7%) памяти устройства. Всего доступно 32256 байт.
  Глобальные переменные используют 139 байт (6%) динамической памяти, оставляя 1909 байт для локальных переменных. Максимум: 2048 байт.
*/

Да ,время растянул работает.Еще потенциометр.Он по моему не связан с переменной тайм2

//--------------------Cl_Potentiometer---------------------------------------------
// класс потемциометр . Меняет значение внешней переменной в зависимости от ручки потенциометра
class Cl_Potentiometer {
    const byte _pin;
    int *const _pntTemp;// указатель переменную которая меняет значение температуры по положению ручки потенциометра(входящее значение)
    int *const _pntTime;// указатель переменную которая меняет значение времени по положению ручки потенциометра
    uint32_t past = 0;
  public:
    Cl_Potentiometer(byte pin, int *pntTemp, int *pntTime): _pin(pin), _pntTemp(pntTemp), _pntTime(pntTime) {}
    void setup() {
      *_pntTime = _pntTemp + map(analogRead(_pin), 0, 1023, 10, 200); //<--- здесь функция поворота ручки в значение
    }
    void loop() {
      if (micros() - past > 100) {
        *_pntTime = _pntTemp + map(analogRead(_pin), 0, 1023, 10, 200); //<--- здесь функция поворота ручки в значение
      }
    }
};

это с преведущего

Запустите этот код и наблюдайте на мониторе изменения тайм2

/*
  ардуино пин A0 <--> средний вывод потенциометра
  ардуино пин 2 <--> датчик холла 1 запуск инжектора на каждый горшок
  ардуино пин 3 <--> датчик холла 2 установка 1 горшка
  ардуино пин 6 <--> инжектор 1
  ардуино пин 7 <--> инжектор 2
  ардуино пин 8 <--> инжектор 3
  ардуино пин 9 <--> инжектор 4
  Запуск системы через 2 секунды.
   подготовка еще 0,2 секунды - все инжекторы работают
*/
uint32_t micro, mill; // переменные для micros() и millis()
//------------Cl_Inject------------------------------
// класс инжектор
class Cl_Inject {
    const byte pin;// нога
    const bool inv;// инверсия выхода
    uint32_t *pnt_time1, *pnt_time2; // указатели на время задержки и времени впрыска
    uint32_t time1, time2; // время задержки и времени впрыска
    byte stat = 0; //2(1этап)/1(2этап)/ 0 стоп
    uint32_t past;
  public:
    Cl_Inject(byte _pin, bool _inv, uint32_t *_pnt_time1, uint32_t *_pnt_time2)
      :        pin(_pin), inv(_inv),   pnt_time1(_pnt_time1),     pnt_time2(_pnt_time2) {}
    void setup() {
      pinMode(pin, OUTPUT);
      stat = 0;
      digitalWrite(pin, inv); // выключить инжектор
    }
    void loop() {
      if (stat == 2 && micro - past >= time1) { // если подошло время включить инжектор
        stat = 1;
        past = micro;
        digitalWrite(pin, !inv); // то включить инжектор
      }
      if (stat == 1 && micro - past >= time2) { // если подошло время выключить инжектор
        stat = 0;
        digitalWrite(pin, inv); // то выключить инжектор
      }
    }
    void inject() {
      time1 = *pnt_time1;
      time2 = *pnt_time2;
      Serial.println(*pnt_time2);
      stat = 2;
      past = micro;
    }
};
//--------------------Cl_Potentiometer---------------------------------------------
// класс потенциометр
class Cl_Potentiometer {
    const byte _pin;
    uint32_t *const _pnt;// указатель переменную которая меняет значение по положению ручки потенциометра
    uint32_t past = 0;
  public:
    Cl_Potentiometer(byte pin, uint32_t *pnt): _pin(pin), _pnt(pnt) {}
    void setup() {
      *_pnt = 10000ul / 1023 * analogRead(_pin); // значение впрыска меняется от 0 до 10 000 микросек
    }
    void loop() {
      if (mill - past > 100) {
        *_pnt = 10000ul / 1023 * analogRead(_pin);
        past = mill;
      }
    }
};
//-----------------Cl_Hall---------------------------------
// класс датчика Холла
class Cl_Hall {
    const byte pin;// нога
    const bool inv;// инверсия выхода
    void (*Do)();// указатель на обработчик
    bool Hall, Hall_old;
  public:
    Cl_Hall(byte _pin, bool _inv, void (*_Do)())
      :      pin(_pin), inv(_inv),    Do(_Do)  {}
    void setup() {
      pinMode(pin, INPUT);
      Hall_old = digitalRead(pin)^inv;
    }
    void loop() {
      Hall = digitalRead(pin)^inv;
      if (Hall && !Hall_old ) {
        Hall_old = 1;
        Do();
      }
      if (!Hall && Hall_old ) {
        Hall_old = 0;
      }
    }
};
//----------Cl_Hall2_Inject4-----------------------------------------
// класс из 2-x датчиков Холла и 4-x инжекторов
class Cl_Hall2_Inject4 {
    Cl_Hall Hall_1, Hall_2;
    Cl_Inject Inject1, Inject2, Inject3, Inject4;
    byte num = 0; // номер инжектора для текущей инжекции
    byte stat = 0; // 0 отключен / 1 подготовка / 2 работа
  public:
    Cl_Hall2_Inject4(byte _pin1, byte _pin2, bool _invH, void (*_Do1)(), void (*_Do2)(),
                     byte _pin3, byte _pin4, byte _pin5, byte _pin6, bool _invI, uint32_t *_pnt_time1, uint32_t *_pnt_time2)
      : Hall_1(_pin1, _invH, _Do1), Hall_2(_pin2, _invH, _Do2),
        Inject1(_pin3, _invI, _pnt_time1, _pnt_time2), Inject2(_pin4, _invI, _pnt_time1, _pnt_time2),
        Inject3(_pin5, _invI, _pnt_time1, _pnt_time2), Inject4(_pin6, _invI, _pnt_time1, _pnt_time2) {}
    void setup() {
      Hall_1. setup();
      Hall_2. setup();
      Inject1. setup();
      Inject2. setup();
      Inject3. setup();
      Inject4. setup();
    }
    void loop() {
      if (stat == 0) return;
      Hall_1. loop();
      Hall_2. loop();
      Inject1. loop();
      Inject2. loop();
      Inject3. loop();
      Inject4. loop();
    }
    void inject() {
      if (stat == 0) return;
      if (stat == 1) {
        Inject1.inject();
        Inject2.inject();
        Inject3.inject();
        Inject4.inject();
      }
      if (stat == 2) {
        switch (num) {
          case 0:
            Inject1.inject();
            break;
          case 1:
            Inject2.inject();
            break;
          case 2:
            Inject3.inject();
            break;
          case 3:
            Inject4.inject();
            break;
        }
        ++num; if (num > 3)num = 0;
      }
    }
    void clear() {
      num = 0;
    }
    void preparation() {// включить подготовку
      stat = 1;
    }
    void work() {// включить работу
      stat = 2;
    }
};
//----------------Cl_Delay-------------------------------
// класс задержка запуск системы через некоторое время
class Cl_Delay {
    uint32_t time1, time2;
    void (*Do1)(), (*Do2)();
    byte stat = 0; // 0 - пауза / 1 - подготовка /2 - работа
    uint32_t past = 0;
  public:
    Cl_Delay(uint32_t _time1, void (*_Do1)(), uint32_t _time2, void (*_Do2)())
      : time1(_time1), Do1(_Do1), time2(_time2), Do2(_Do2) {}
    void loop() {
      if (stat == 0 && mill - past >= time1) {
        past = mill;
        stat = 1;
        (*Do1)();
      }
      if (stat == 1 && mill - past >= time2) {
        past = mill;
        stat = 2;
        (*Do2)();
      }
    }
};
//--------------компоновка----------------------------
uint32_t time1 = 1000; // время задержки впрыска ,микросек
uint32_t time2 = 6000; // время  впрыска  ,микросек
Cl_Potentiometer Potentiometer(/*пин потенциометра*/A0,/*переменая*/&time2);// подключить потенциометр
void Do_Inject();
void Do_Clear();
Cl_Hall2_Inject4  Hall2_Inject4(/*нога датчика*/2,/*нога датчика*/3,/*инвесия ввода*/0,/*обработчик1*/Do_Inject,/*обработчик2*/Do_Clear,
    /*нога инжектора1*/6,/*нога инжектора2*/7,/*нога инжектора3*/8,/*нога инжектора4*/9,/*инвесия вывода*/0,/**/&time1,/**/&time2);
void Do_Inject() {
  Hall2_Inject4.inject();
}
void Do_Clear() {
  Hall2_Inject4.clear();
}
void Do1_Delay() {
  Hall2_Inject4.preparation();
}
void Do2_Delay() {
  Hall2_Inject4.work();
}
Cl_Delay Delay(
  /*задержка 2 сек*/2000,                           // пауза
  /*обработчик*/Do1_Delay, /*задержка 0,2 сек*/200, // подготовка
  /*обработчик*/Do2_Delay);                         // работа
//-------------main()-----------------------------
void setup() {
  Serial.begin(9600);
  Potentiometer.setup();
  Hall2_Inject4.setup();
}
void loop() {
  micro = micros();
  mill = millis();
  Potentiometer.loop();
  Hall2_Inject4.loop();
  Delay.loop();
}
/*
  Скетч использует 3542 байт (10%) памяти устройства. Всего доступно 32256 байт.
  Глобальные переменные используют 316 байт (15%) динамической памяти, оставляя 1732 байт для локальных переменных. Максимум: 2048 байт.
*/

Нет не меняется ,может я чего то не допонимаю но функция  analogRead меняет значение int (0 to 1023) а в у вас в каде прописано

 void setup() {
058
      *_pnt = 10000ul / 1023 * analogRead(_pin); // значение впрыска меняется от 0 до 10 000 микросек
059
    }
060
    void loop() {
061
      if (mill - past > 100) {
062
        *_pnt = 10000ul / 1023 * analogRead(_pin);

первоначальное значение ноль у вас же 10000ул что просто выстовляет значение в компорте 10000ул .

Этот код я думаю вернее

 void setup() {
11
      *_pntTime = _pntTemp + map(analogRead(_pin), 0, 1023, 10, 200); //<--- здесь функция поворота ручки в значение
12
    }
13
    void loop() {
14
      if (micros() - past > 100) {
15
        *_pntTime = _pntTemp + map(analogRead(_pin), 0, 1023, 10, 200); //<--- здесь функция поворота ручки в значение

первые два значения это условные для программы  это 1024 шага с разрешением 0.0049 Вольт а следующие 2 регулируются.почемуто в справочнике это не указано там сделали ссылку на функцию analogReference().

Вот скетч. Он выводит в монитор числа от 0 до 1023 от поворота ручкой с частотой 0.5 секунды

/*
*/
uint32_t mill;// переменная под millis();
//-------Cl_Potentiometer-----------------------------------
class Cl_Potentiometer {
    const byte pin;
    uint32_t past = 0;
  public:
    Cl_Potentiometer (byte _pin): pin(_pin) {}
    void loop() {
      if (mill - past >= 500) {
        past = mill;
        Serial.println(analogRead(pin));
      }
    }
};
//------Компоновка------------------
Cl_Potentiometer Potentiometer(/*пин*/A0);
//------main()---------------------
void setup() {
  Serial.begin(9600);

}

void loop() {
  mill = millis();
  Potentiometer.loop();
}
/*Скетч использует 1866 байт (5%) памяти устройства. Всего доступно 32256 байт.
Глобальные переменные используют 195 байт (9%) динамической памяти, оставляя 1853 байт для локальных переменных. Максимум: 2048 байт.
*/

Но мне хотелось бы что бы числа менялись от 100 до 10000 , микросекунд конечно

Ну где-то так

/*
*/
uint32_t mill;// переменная под millis();
//-------Cl_Potentiometer-----------------------------------
class Cl_Potentiometer {
    const byte pin;
    uint32_t past = 0;
  public:
    Cl_Potentiometer (byte _pin): pin(_pin) {}
    void loop() {
      if (mill - past >= 500) {
        past = mill;
        uint32_t val = 9900ul / 1023 * analogRead(pin) + 100;
        Serial.println(val);
      }
    }
};
//------Компоновка------------------
Cl_Potentiometer Potentiometer(/*пин*/A0);
//------main()---------------------
void setup() {
  Serial.begin(9600);

}

void loop() {
  mill = millis();
  Potentiometer.loop();
}
/*Скетч использует 1800 байт (5%) памяти устройства. Всего доступно 32256 байт.
Глобальные переменные используют 195 байт (9%) динамической памяти, оставляя 1853 байт для локальных переменных. Максимум: 2048 байт.
*/

Разумеется это величина длительности впрыска инжектора.

Вот скетч с записью показаний в переменную

/*
*/
uint32_t mill;// переменная под millis();
//-------Cl_Potentiometer-----------------------------------
class Cl_Potentiometer {
    const byte pin;
    uint32_t past = 0;
    uint32_t *pnt; // указатель на переменную впрыска
  public:
    Cl_Potentiometer (byte _pin, uint32_t *_pnt)
      : pin(_pin), pnt(_pnt) {}
    void loop() {
      if (mill - past >= 500) {
        past = mill;
        uint32_t val = 9900ul / 1023 * analogRead(pin) + 100;
        Serial.println(val);
      }
    }
};
//------Компоновка------------------
uint32_t time2 = 100; // время впрыска
Cl_Potentiometer Potentiometer(/*пин*/A0,/*переменая*/&time2);
//------main()---------------------
void setup() {
  Serial.begin(9600);

}

void loop() {
  mill = millis();
  Potentiometer.loop();
}
/*Скетч использует 1812 байт (5%) памяти устройства. Всего доступно 32256 байт.
  Глобальные переменные используют 201 байт (9%) динамической памяти, оставляя 1847 байт для локальных переменных. Максимум: 2048 байт.
*/

 опять протупил запись не сделал

/*
*/
uint32_t mill;// переменная под millis();
//-------Cl_Potentiometer-----------------------------------
class Cl_Potentiometer {
    const byte pin;
    uint32_t past = 0;
    uint32_t *pnt; // указатель на переменную впрыска
  public:
    Cl_Potentiometer (byte _pin, uint32_t *_pnt)
      : pin(_pin), pnt(_pnt) {}
    void loop() {
      if (mill - past >= 500) {
        past = mill;
        uint32_t val = 9900ul / 1023 * analogRead(pin) + 100;
        *pnt = val; //<--- опять протупил запись не сделал
        Serial.println(val);
      }
    }
};
//------Компоновка------------------
uint32_t time2 = 100; // время впрыска
Cl_Potentiometer Potentiometer(/*пин*/A0,/*переменая*/&time2);
//------main()---------------------
void setup() {
  Serial.begin(9600);

}

void loop() {
  mill = millis();
  Potentiometer.loop();
}
/*Скетч использует 1828 байт (5%) памяти устройства. Всего доступно 32256 байт.
  Глобальные переменные используют 201 байт (9%) динамической памяти, оставляя 1847 байт для локальных переменных. Максимум: 2048 байт.
*/

Извеняюсь у меня похоже чтото с выходом 0А было.Контакт или сам выход шивелил ни чего не происходило.Выдернул по новой вставил все скечи заработали.

Большое спасибо за помощь и терпение.Теперь можно поробовать установить и отрегулировать на авто.

Как говаривал Юрий Иосифович Визбор: "вот тут и начинается кино!" :))))))))))

Да нет здесь кино не начинается,это только анонс.Кино начнется после настройки холостых.Первый фильм называется,Ускорение а второй Ускорние при нагрузке.

Это Вам так кажется. На самом же деле, ускорения - это уже второй и третий сезоны сериала.

Нет не кажется.Если зажигание выстовленно правельно с движком все в порядке то он будет заводится и работать даже с обычного медицинского шприца,пока в нем бензин не закончится.

Прицип работы карбюратора через жиклер холостого хода.

Ну, разве что:)

Дерзайте.

qwone а как в классах прописать тахометр?

100500 тахометров! О_О

Какой тахометр?

//--------------------Cl_RPM---------------------------------------------
// класс измерителя оборотов
//class Cl_RPM {
    unsigned long lastflash;
 // const byte pin;// нога
   // const bool inv;// инверсия выхода
    int RPM;
  //public: 
 // Cl_RPM (byte _pin,bool _inv):pin(_pin), inv(_inv){}
void setup() {
 Serial.begin(9600);  //открыть порт  
  attachInterrupt(0,sens,RISING); //подключить прерывание на 2 пин при повышении сигнала
  pinMode(2, OUTPUT);   //2 пин как выход
  digitalWrite(2, HIGH);  //подать 5 вольт на 2 пин
}
void sens() {
  RPM=60/((float)(millis()-lastflash)/1000);  //расчет
  lastflash=millis();  //запомнить время последнего оборота
}

void loop() {
  if ((millis()-lastflash)>5000){ //если сигнала нет больше секунды
    RPM=0;  //считаем что RPM 0
  }
  Serial.println(RPM);   //вывод в порт
    delay(50);  //задержка для стабильности
  }
//};
//--------------компоновка---------------------------- 

//-------------main()----------------------------
//void setup() {
  

//}

//void loop() {
 

//}

Я тут какбы попробовал и кампилятор пропустил этот код.но на манитор он не выводит.В орегинале время в микрос.И у меня возник вопрос как избавится от делей и как воспользоватся милис но не микрос?

Видите ли. У меня нет приемлимой теории программирования на Си++. То что я прочитал в книгах по мне сыровато. Так что попробую выложить свои тезизы. Инкапсуляция  - в информатике упаковка данных и функций в единый компонент.  Но по мне это немного не верно. Есть данные и вот в них упаковывается код. Но не наоборот. В код (в класс кода) вставляются данные. Опять же не надо путать данные и переменные. Это различные понятия . Хотя данные одного класса могут становиться переменными. 

И так в классе тахометра данные это скорость и все. Больше данных в классе тахометра нет. А все что не данные это переменные. Теперь надо решить как делать доступ к этим данным (этой данной) Внутреней

//------------Cl_tachometer---------------------------------
// класс тахометр
class Cl_tachometer {
  public:
    int  value = 0;
};
//---------Компановка------------------------------------
Cl_tachometer Tachometer;
//--------main()-------------------------------------
void setup() {
  Serial.begin(9600);
  Serial.println(Tachometer.value);
}

void loop() {
}
/*Скетч использует 1652 байт (5%) памяти устройства. Всего доступно 32256 байт.
  Глобальные переменные используют 186 байт (9%) динамической памяти, оставляя 1862 байт для локальных переменных. Максимум: 2048 байт.
*/

или внешней.

//------------Cl_tachometer---------------------------------
// класс тахометр
class Cl_tachometer {
    int  *value;
  public:
    Cl_tachometer(int  *_value): value(_value) {}

};
//---------Компановка------------------------------------
int speed = 0;
Cl_tachometer Tachometer(/*скорость*/&speed);
//--------main()-------------------------------------
void setup() {
  Serial.begin(9600);
  Serial.println(speed);
}

void loop() {
}
/*Скетч использует 1722 байт (5%) памяти устройства. Всего доступно 32256 байт.
  Глобальные переменные используют 190 байт (9%) динамической памяти, оставляя 1858 байт для локальных переменных. Максимум: 2048 байт.
*/

Я решил поставить на авто нано (будет управлять искрой)и мега инжектором. Можно на оборот, а через прерывание передовать импульс и время опережения.Опережение уже зависит от тахометра.А вот как делать доступ я не знаю это для меня ново.Как подключать через сериал айтуси тоже еще не знаю мне нужно чтобы было быстро но эфективно. 

Если вы про связь двух ардуин. То к сожелению я пока этим не занимался. Я по этой причине начал заниматься как упоковать кучу всего в одну ардуину, что бы не делать пакет из ардуин.

п.с Но только если одна по времени это все не успеет.  

/**/
uint32_t mill;
//------------Cl_tachometer---------------------------------
// класс тахометр
class Cl_tachometer {
    int  *value;
    unsigned int *turn;
    uint32_t past;
  public:
    Cl_tachometer(int  *_value, unsigned int *_turn): value(_value), turn(_turn) {}
    void setup() {
      *value = 0; *turn = 0;
      past = mill;
    }
    void loop()  {
      if (mill - past >= 1000) {
        cli();
        *value = *turn;
        *turn = 0;
        sei();
        Serial.println(*value);
      }
    }
};
//---------Компановка------------------------------------
int speed = 0;
volatile unsigned int turn;
void Interrupt() {
  ++turn;
}
Cl_tachometer Tachometer(/*скорость*/&speed,/*счетчик оборотов*/& turn);
//--------main()-------------------------------------
void setup() {
  Serial.begin(9600);
  attachInterrupt(/*пин прерывания*/0, Interrupt, RISING);
  Tachometer.setup() ;
}

void loop() {
  mill = millis();
  Tachometer.loop();
}
/*Скетч использует 2102 байт (6%) памяти устройства. Всего доступно 32256 байт.
  Глобальные переменные используют 206 байт (10%) динамической памяти, оставляя 1842 байт для локальных переменных. Максимум: 2048 байт.
*/

В работе код не проверял.

Не работает,

/*
Created 2016
by AlexGyver
AlexGyver Home Labs Inc.
*/

unsigned long lastflash;
int RPM;

void setup() {
  Serial.begin(9600);  //открыть порт
  attachInterrupt(0,sens,FALLING); //подключить прерывание на 2 пин при повышении сигнала
  pinMode(3, OUTPUT);   //3 пин как выход
  digitalWrite(3, HIGH);  //подать 5 вольт на 3 пин
}
void sens() {
  RPM=60/((float)(millis()-lastflash)/1000);  //расчет
  lastflash=millis();  //запомнить время последнего оборота
}

void loop() {
  if ((millis()-lastflash)>1000){ //если сигнала нет больше секунды
    RPM=0;  //считаем что RPM 0
  }
  Serial.println(RPM);   //вывод в порт
  delay(50);  //задержка для стабильности
}

вот рабочий код.

qwone в этом коде с патенциометром проблемма инжектор при наборе оборотов перестает реагировать на новый импульс.Он просто открывается и не закрывается пока не остановишь двигатель.А точнее если обороты не снизишь ниже 80,двигатель глохнет уже на 550.Да и форсы от такой работы повылетают через минут 10-15.

/*
  ардуино пин A1 <--> на вывод термистора // cчитаем еще один потенциометр
  ардуино пин A0 <--> средний вывод потенциометра
  ардуино пин 2 <--> датчик холла 1
  ардуино пин 3 <--> датчик холла 2
  ардуино пин 4 <--> датчик холла 3
  ардуино пин 5 <--> датчик холла 4
  ардуино пин 6 <--> инжектор 1
  ардуино пин 7 <--> инжектор 2
  ардуино пин 8 <--> инжектор 3
  ардуино пин 9 <--> инжектор 4
*/

/*
//--------------------Cl_Temp---------------------------------------------
// класс измерителя температуры
class Cl_Temp {
    const byte _pin;
    int *const _pntTemp;// указатель переменную которая меняет значение температуры по положению ручки потенциометра
    uint32_t past = 0;
  public:
    Cl_Temp(byte pin, int *pntTemp): _pin(pin), _pntTemp(pntTemp) {}
    void setup() {
      *_pntTemp = map(analogRead(_pin), 0, 1023, 0, 0);//<--- здесь функция поворота ручки в значение температуры
    }
    void loop() {
      if (millis() - past > 100) {
        *_pntTemp = map(analogRead(_pin), 0, 1023, 0, 0);//<--- здесь функция поворота ручки в значение температуры
      }
    }
};*/
//--------------------Cl_Potentiometer---------------------------------------------
// класс потемциометр . Меняет значение внешней переменной в зависимости от ручки потенциометра
class Cl_Potentiometer {
    const byte _pin;
    int *const _pntTemp;// указатель переменную которая меняет значение температуры по положению ручки потенциометра(входящее значение)
    int *const _pntTime;// указатель переменную которая меняет значение времени по положению ручки потенциометра
    uint32_t past = 0;
  public:
    Cl_Potentiometer(byte pin, int *pntTemp, int *pntTime): _pin(pin), _pntTemp(pntTemp), _pntTime(pntTime) {}
    void setup() {
      *_pntTime = _pntTemp + map(analogRead(_pin), 0, 1023, 0, 0); //<--- здесь функция поворота ручки в значение
    }
    void loop() {
      if (millis() - past > 1) {
        *_pntTime = _pntTemp + map(analogRead(_pin), 0, 1023, 0, 0); //<--- здесь функция поворота ручки в значение
      }
    }
};
//--------------------Cl_HallToInject-------------------------------
// класс Датчик Холла задает начало открытия инжектора
class Cl_HallToInject {
    uint32_t time = 0; // длительность 1 секунда
    int *const _pnt;// указатель переменную которая задает новое значение time
    const byte _Hall_pin  ; // пин холла
    const byte _Inject_pin;// пин инжектора
    bool Hall, Hall_old;
    bool Inject;
    bool _invH, _invI; // инверсия выходов датчика Холла и инжектора
    uint32_t past = 0;
  public:
    Cl_HallToInject(byte Hall_pin, bool invH, byte Inject_pin, bool invI, int *pnt)
      : _Hall_pin(Hall_pin), _invH(invH), _Inject_pin(Inject_pin), _invI(invI) , _pnt(pnt) {}
    void setup() {
      pinMode(_Hall_pin, INPUT);
      Hall_old = _invH ^ digitalRead( _Hall_pin);
      pinMode(_Inject_pin, OUTPUT);
      Inject = 0;
      digitalWrite(_Inject_pin, _invI ^ Inject);
    }
    void loop() {
      Hall = _invH ^ digitalRead( _Hall_pin);
      if (Hall && !Hall_old) { // если сработал датчик Холла
        Hall_old = 1;
        Inject = 1;            // то вкл Инжектор
        digitalWrite(_Inject_pin, _invI ^ Inject);
        time = *_pnt; // выставить новое время впрыска
        past = millis();
      }
      else if (!Hall && Hall_old) {
        Hall_old = 0;
      }
      if (Inject && millis() - past >= time) { // если истекло время
        Inject = 0;                            // то выкл Инжектор
        digitalWrite(_Inject_pin, _invI ^ Inject);
      }
    }
};
//------------------Компоновка---------------------------------
int temp = 0; // температура
int time = 1; // длительность впрыска

//Cl_Temp Temp(/*пин потенциометра*/A1,/*переменая*/&temp);// подключить термометр
Cl_Potentiometer Potentiometer(/*пин потенциометра*/A0,/* входная переменая*/&temp,/*выходная переменая*/&time);// подключить потенциометр
// Замечание: Если вам нужно проинвертировать сигнал, то замените 0 на 1
Cl_HallToInject HallToInject1(/*датчик Холла*/11,/*инверт сиг с датХолла*/1,/*инжектор*/6,/*инверт сиг на инжектор*/1,/*время впрыска*/&time);
Cl_HallToInject HallToInject2(/*датчик Холла*/10,/*инверт сиг с датХолла*/1,/*инжектор*/7,/*инверт сиг на инжектор*/1,/*время впрыска*/&time);
Cl_HallToInject HallToInject3(/*датчик Холла*/4,/*инверт сиг с датХолла*/1,/*инжектор*/8,/*инверт сиг на инжектор*/1,/*время впрыска*/&time);
Cl_HallToInject HallToInject4(/*датчик Холла*/5,/*инверт сиг с датХолла*/1,/*инжектор*/9,/*инверт сиг на инжектор*/1,/*время впрыска*/&time);
//------------------main()---------------------------------
void setup() {
  Serial.begin(9600);
//  RPM.setup();
 // Temp.setup();
  Potentiometer.setup();
  HallToInject1.setup();
  HallToInject2.setup();
  HallToInject3.setup();
  HallToInject4.setup();
}

void loop() {
  Serial.println(time);

 // Temp.loop();
  Potentiometer.loop();
  HallToInject1.loop();
  HallToInject2.loop();
  HallToInject3.loop();
  HallToInject4.loop();
}

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

Потенциометр что показывает я понять не могу у меня 103 переменный резистор,минимальное в ком порте, от нуля 770, если 3-4-5-6 падает до 500, потом снова рости начинает.И у себя в классах ардуино по qwone для чайников исправь а то чайники все фарсунки попалят.  

Идея очень интересная, так как у меня большой опыт в инжекторе КЕ-Джетроник там форсунки механические и туда подаютя через дозатор. У вас по ходу электронные форсунки их нужно будет управлять зависомости от датчика коленвала для определения ВМТ . 

Нет от датчика коленвала я избавился он считает градусы.Все это дело работает по картам по графикам что перегружает память.Проще установить на распредвале.

А форсы у меня электронные уже переходники готовы осталось проводку кинуть,родные свое уже отходили поставил от хендей элиза с лучшим распылением.

Заработало? интересно узнать получилось ли? 

Да работает. Пробовал на холостых.Движек1350 расточен 1400 кубиков 1 милисикунда задержки,давление не измерял, нечем, примерно 2,5 отмосферы.Думаю задержку в микросек попробовать транзисторы не тянут.В старом ЭБУ один стоит.

Только сейчас подбираю ключи,у меня слабые,греются сильно.КТ815 КТ817 держат но задержка большая,они теперь ток держат наполнение очень низкое.В поисках заморского чуда.  

Еще проблема в скече два холла на 4 инжектора если сгорает транзистор или коротит сеть,скечь приходится загружать по новой перезагрузка не помогает .По какой-то причине, при кз, скечь начинает работать сам по себе,без холлов, инжектора включаются сами по себе.

Работает пока без нареканий 4холла 4 инжектора+потенциометр.Спецом спалил 2 транзистора, делал кз, скечь работает.

Если считать что за 4 такта при ХХ к-джетроник работает 160 милисикунд то у меня он работает 1 милисекунду я на холостых экономлю  159 милисикунд топлива.Так что вылазь из пацтала.

Откуда берется сигнал на впрыск форсунок, так как впрыск идет до 75гр до ВМТ поршня 

Что за глупость ????

И что, расход на холостых упал в 160 раз? :) На 1 литре будет неделю молотить без остановки?

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

Пытаюсь настроить чтоб на холостых работал как дизель (неделю)....ну не в 160 раз раз на 100-120 расч

итываю, давление которое собирается за 158 милисекунд тоже надо учитывать.

Хотя я снизил его на холостых на 0,5-1 атмасферу.

Можно и гибрид собрать.Только идея чуть чуть другая на воде 

Ну так каковы результаты, обнародуй? Или это все в мечтах?

Сейчас подбираю транзисторы.Те которые были в наличии греются и перегорают,завтра попробую на 8А импулс 12А думаю заработает, родной ключь всего один на 4А мне нужно четыре.

Я у вас спрашивал откуда берете сигнал с коленвала или от датчика тахометра TD. Тоже собрал блок для гбо ардуино UNO на выходе поставил полевые логические транзисторы(40 ампер) модель точно уже не помню катаюсь уже больше 10 000км без проблем