Arduino.ru

А по подробнее про команду на прогрев? Выдать 5 вольт куда то, пока температура меньше 70? При нажатии на газ просто не выдавать запреты на горшки? А как быть при движении накатом? 

а потом все как грабли,на газ нажал а она не едет

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

1.первое что должен сделать контроллер при включении дать на все инжекторы пусковую задержку 1.5-2 сикунды.

2.дальше он должен найти первый цилиндр и дать команду на выполнение цикла.

3.далее он должен установить больше или меньше +35 градусов температура охлождающей жидкости.если температура больше он пропускает эту функцию.если меньше то должен добавить задержку(если возможность плавного сбрасывания задержки отнимает много памяти на оброботку можно обойтись просто больше меньше)функцию можно выключить или направить на включение вентилятора охлаждающей жидкости.подав на другой пин команду на включение больше или меньше +85

4.если температура больше +30 то отключить функцию прогрева при изменении показаний потенциометра.то что она включится на холостых в этом нет не чего страшного.

Понимаю. Не програмист. Но хоть в терминах програмирования описание можете дать. Ваше описание вызывает много вопросов.

1. Пусковая задержка. Это как? После подачи питания? После подачи напряжения на стартёр? После первого срабатывания датчика холла?

2. Найти первый цилиндр это фронт сигнала датчика хола? Кому дать команду на выполнение цикла? Какого цикла? Импульсы по цилиндрам есть? Или сначала рассчитать время отработки и сам будет отдавать сигналы на горшки?

3. Что значит установить? Отработать нагрев или просто померить температуру? Добавить задержку чего? Тех  2 секунд что в первом пункте?  Включать вентилятор если температура выше 35 градусов? Какой гистерезис?

4. Ещё раз - что такое функция прогрева. Кто греет? В движок лъётся во все цилиндры? Что в это время делает процессор? Накатом холостых не будет. Я понимаю, если педаль отпустили,то вобщем пофиг если форсунки будут запрещаться.

Вопросов много. Все они нужны для того что бы написать программу. Я уже просил описать процессы в элементарных шагах,а не в терминах машины. Неужели трудно? Без этого программы не написать.  

без датчика коленвала не обойтись, он должен задавать начальное положение движка, от которого и надо отталкиваться и считать временные интервалы.  Я не помню, не механик, но памойму на японцах датчик сигнализирует, что первый цилиндр находится в ВМТ (или в начале цикла сжатия).  И четыре датчика надо на распредвал (или по числу горшков), иначе опережение при нажатии на газик сделать будет сложно (оно ж плавающее, зависит от оборотов) 

Датчик каленвала(фаз) определяет положение каленвала по градусам,причем делает это за два оборота что повлияет на время работы скеча.Для этого надо ставить еще одну ардуинко чтоб она производила расчеты и замеры .А 4 датчика можно не ставить,в трамблере 4 шторки и регулеровка зажигания вакумная.Датчику холла не нужно знать где находится каленвал,это упрощает скечь,ему просто нужно знать где находится ВМТ первого цилиндра.

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

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

Они отталкиваются от ЭБУ который выполняет все сам по этому они не могут понять что он не нужен.

Да и ГРМ по меткам выставлять по большому счету не нужно, наерна, нахрена нам начальное положение движка знать, ВМТ там всякие?  И понять, что если обороты растут, то впрыск 4 цилиндра нужно производить быстрее, чем второго,  это тоже так сложно.... 

ГРМ по меткам выставляется один раз при установке ГРМ-ремня или цепи. Далее взаимное положение коленвала и распредвала жестко зафиксировано - зачем его контролировать отдельным датчиком? (кроме ГРМ с изменяемыми фазами, который вряд ли интересует автора).

"Если обороты растут, то впрыск 4 цилиндра нужно производить быстрее, чем второго" - нафига?

Если обороты растут. впрыск чуть смещается вперед ДЛЯ ВСЕХ цилиндров. что легко можно сделать на следующем обороте. А внутри каждого оборота считать частоту вращения КВ постоянной.

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

/*
  ардуино пин A0 <--> средний вывод потенциометра
  ардуино пин 2 <--> датчик холла 1
  ардуино пин 3 <--> датчик холла 2
  ардуино пин 4 <--> датчик холла 3
  ардуино пин 5 <--> датчик холла 4
  ардуино пин 6 <--> инжектор 1
  ардуино пин 7 <--> инжектор 2
  ардуино пин 8 <--> инжектор 3
  ардуино пин 9 <--> инжектор 4
*/
//--------------------Cl_Potentiometer---------------------------------------------
class Cl_Potentiometer {
    const byte _pin;
    int *const _pnt;// указатель переменную которая меняет значение по положению ручки потенциометра
    uint32_t past = 0;
  public:
    Cl_Potentiometer(byte pin, int *pnt): _pin(pin), _pnt(pnt) {}
    void setup() {
      *_pnt = map(analogRead(_pin), 0, 1023, 10, 1000);
    }
    void loop() {
      if (millis() - past > 100) {
        *_pnt = map(analogRead(_pin), 0, 1023, 10, 1000);//<-- видете цифры 10 и 1000 .это и есть выставление пределов изменения
        past=millis();
      }
    }
};
//--------------------Cl_HallToInject-------------------------------
// класс Датчик Холла задает начало открытия инжектора
class Cl_HallToInject {
    uint32_t time = 1000; // длительность 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 time = 1000; // длительность впрыска // здесь только начальная / а фактически в строке 24
Cl_Potentiometer Potentiometer(/*пин потенциометра*/A0,/*переменая*/&time);// подключить потенциометр
// Замечание: Если вам нужно проинвертировать сигнал, то замените 0 на 1
Cl_HallToInject HallToInject1(/*датчик холла*/2,/*инверт сиг с датХолла*/0,/*инжектор*/6,/*инверт сиг на инжектор*/0,/*время впрыска*/&time);
Cl_HallToInject HallToInject2(/*датчик холла*/3,/*инверт сиг с датХолла*/0,/*инжектор*/7,/*инверт сиг на инжектор*/0,/*время впрыска*/&time);
Cl_HallToInject HallToInject3(/*датчик холла*/4,/*инверт сиг с датХолла*/0,/*инжектор*/8,/*инверт сиг на инжектор*/0,/*время впрыска*/&time);
Cl_HallToInject HallToInject4(/*датчик холла*/5,/*инверт сиг с датХолла*/0,/*инжектор*/9,/*инверт сиг на инжектор*/0,/*время впрыска*/&time);
//------------------main()---------------------------------
void setup() {
  Serial.begin(9600);
  Potentiometer.setup();
  HallToInject1.setup();
  HallToInject2.setup();
  HallToInject3.setup();
  HallToInject4.setup();
}

void loop() {
  Serial.println(time);
  Potentiometer.loop();
  HallToInject1.loop();
  HallToInject2.loop();
  HallToInject3.loop();
  HallToInject4.loop();
}

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

Ну лана.  Пусть будет так.  

не нужно ни какие графики вычисления они установленны механическим путем,и регулеровкой потенциометра и температурой.

Положение первого цилиндра нужно знать,при перезагрузки контроллера отсчет начнется с первого цилиндра.А двигатель останавится может на 2,3,4.

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

Где остановился движек знать не нужно, нужно знать где первый.При повороте стартером обороты двигателя могут быть очень низкие.А если учесть что у меня двигатель после капремонта то это еще сильнее усугубит положение. 

Первый оборот стартера будет впустую - а дальше система уже будет знать, где первый. Будет заводится  не "с полоборота", а с полутора. И что? Не вижу в этом никакой трагедии.

а вообще, прочел выше что ЭБУ стоит всего 100уе, нафига все это....  За то время. что ты потратишь на всю эту трахомудию, уже давно можно было заработать на пяток новых блоков.

Да дело не в самой стоимости а в том что это проект мой.Я могу поставит 7.2 Е3 или БОШ.Это мне не интерестно. Я хочу свою систему.Где можно добавить и убрать все как мне хочется.чтобы она была надежна.Вывести на шит приборов то что мне потребуется.Изменять то что мне нужно.К ороче....Это машина просто подопытный кролик.

И у ЭБУ нужно перезагружать и обкатывать карты я хочу решить эту проблемму.без перепрошивки.

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

Как бы это попроще сказать. Вы ответить на вопрос можите или у вас в голове свои мысли клубятся и не дают правильно построить последовательность действий? Вы хотите программу для управления электрической схемой. Во первых где она? Хоть фото отруки нарисованной, что бы понимать на какие ноги сигналы програмировать. Во вторых программа это последовательность действий. Вот вы включили зажигиние. Через сколько секунд включается стартер? У меня бывает минут 10 музыку слушаю, пока жена до машины дойдет. Только потом завожу. Если ардуина включается с зажиганием, а стартер крутанётся через 10 секунд эти 2 секунды после включения уже давно пройдут. И две секунды для бензонасоса тоже пройдут. И что? Ещё 2 секунды бензин гнать надо после включения стартёра? Может на ардуину сигнал стартёр завести и от него работу отсчитывать?

https://vk.com/popkorn_na_dom

Посмотрев разобравшись на примере этого кода постораюсь обьяснить что мне нужно.....

/*

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

*/

нам нужно исправить код ,пока мы пропускаем этот код..

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

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

и как я понимаю нам нужно добавить класс для датчика ВМТ.

//--------------------Cl_HallToVMT-------------------------------
// класс Датчик Холла задает положение ВМТ
class Cl_HallToVMT {

void setup() { } void loop() { }

};

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

Дальше нужно изменить класс Cl_HallToInject прописать чтобы датчик холла 1 по очереди включал инжектора 1,2,3,4 которые не должны зависить от оканьчаний преведущего,то есть был нахлест по времени не должны быть зависимыми друг от друга.Инжектора берут время задержки в переменной (time).В переменной тайм находится время открытия инжекторов на холостом ходу и изменяется в коде.В переменную также получаются значения с переменных температуры и потенциометра и складываются(не умножаются не отнимаются не заменяются а складываются + знаете что за знак) Инверсия решает проблемы вопроса фронта.

//--------------------Cl_HallToInject-------------------------------
// класс Датчик Холла задает начало открытия инжектора
class Cl_HallToInject {
    uint32_t time = 1000000; // длительность 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 = micros();
      }
      else if (!Hall && Hall_old) {
        Hall_old = 0;
      }
      if (Inject && micros() - past >= time) { // если истекло время
        Inject = 0;                            // то выкл Инжектор
        digitalWrite(_Inject_pin, _invI ^ Inject);
      }
    }
};

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

Вообше-то в замке зажигания существует положение где все прекрасно работает и без включения зажигания.Это к праграмме не относится когда закрутится стартер.Программа должна позаботится о том чтобы все форсунки были закрыты если двигатель не завелся или забыли выключить зажигание.А причем здесь схема если в коде подробно написано какой пин ардуины на кодой датчик подключен.

Да, я чуствую это будет долго.

Ну ну. В машине 12 вольт, ардуино 5. Надо согласовывать. В машине полно помех. Надо фильтровать. Вы так и не ответили в какой момент через 2 секунды лить 2 секунды бензин. Я пас.

12 вольт и 5 это уже другая история которая не относится к программированию.Но если ради интереса то ардуино будет впаевается в сгоревший ЭБУ там все учитано и 5 вольт и 12 и части микросхемы можно использовать в своих интересах.

А можно воткнуть на прямую, что ненужно выгарит.

qwone давайте доделаем начатое пока кончились вопросы и никто не мешает.

Так кривовато код у меня выходит. Вы думаете я не пытался. Если будет, то опять недоделка.

 

Я вот тоже попробовал вставить блинк тоже не то.Он работает но его что то остонавливает в вашем коде и задержка работает промерно до 100 милисикунд,больше не получается.

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

 

byte injector_Pin_1 = 6;                    // пин для подключения инжектора1
byte injector_Pin_2 = 7;                    // пин для подключения инжектора2
byte injector_Pin_3 = 8;                    // пин для подключения инжектора3
byte injector_Pin_4 = 9;                    // пин для подключения инжектора4
byte in_Hall_Sensor_Pin = 2;                // пин для подключения датчика холла
byte Hall_Sensor_Pin_VMT = 3;               // пин для подключения датчика холла ВМТ

byte val;                                   //
byte state;                                 //переменная состояния холла
byte c;                                     //

void setup()
{
  pinMode(injector_Pin_1, OUTPUT);          //
  pinMode(injector_Pin_2, OUTPUT);          //
  pinMode(injector_Pin_3, OUTPUT);          //
  pinMode(injector_Pin_4, OUTPUT);          //
  pinMode(in_Hall_Sensor_Pin, INPUT);       //
              //пусковая задержка после каждого вкл зажигания
  digitalWrite(injector_Pin_1, LOW);        //
  digitalWrite(injector_Pin_2, LOW);        //
  digitalWrite(injector_Pin_3, LOW);        //
  digitalWrite(injector_Pin_4, LOW);        //
  delay(1500);                              //время пусковой задержки 
  Serial.begin(9600);                       //
}

void loop()
{
  state = digitalRead(in_Hall_Sensor_Pin);  //

  if (state == HIGH && c == 0)              // холл включился
  {
    c = 1;                                  //
  }
  if (state == LOW && c == 1)               // холл выключился
  {
    val = ++val;
    if (val == 5)                           //
    {
      val = 1;                              //
    }
    c = 0;                                  //
  }

  if (val == 0)   // выключаем инжектора
  {
    digitalWrite(injector_Pin_1, HIGH);     //
    digitalWrite(injector_Pin_2, HIGH);     //
    digitalWrite(injector_Pin_3, HIGH);     //
    digitalWrite(injector_Pin_4, HIGH);     //
  }
  if (val == 1)    // работает первый инжектор
  {
    digitalWrite(injector_Pin_1, LOW);      //
    digitalWrite(injector_Pin_2, HIGH);     //
    digitalWrite(injector_Pin_3, HIGH);     //
    digitalWrite(injector_Pin_4, HIGH);     //
  }
  if (val == 2)     // работает второй инжектор
  {
    digitalWrite(injector_Pin_1, HIGH);     //
    digitalWrite(injector_Pin_2, LOW);      // 
    digitalWrite(injector_Pin_3, HIGH);     //
    digitalWrite(injector_Pin_4, HIGH);     //   
  }
  if (val == 3)      // работает третий инжектор
  {
    digitalWrite(injector_Pin_1, HIGH);     //
    digitalWrite(injector_Pin_2, HIGH);     //
    digitalWrite(injector_Pin_3, LOW);      //
    digitalWrite(injector_Pin_4, HIGH);     //
  }
  if (val == 4)       // работает четвертый инжектор
  {
    digitalWrite(injector_Pin_1, HIGH);     //
    digitalWrite(injector_Pin_2, HIGH);     //
    digitalWrite(injector_Pin_3, HIGH);     //
    digitalWrite(injector_Pin_4, LOW);      //
  }   
  
}

Вот пока то что у меня получилось,теперь надо датчик ВМТ задействовать.

infyniti Начинать надо с параллелизма работы компонентов https://habrahabr.ru/company/intel/blog/80342/

Вот класс обычного инжектора 

/**/
uint32_t micro;
//------------Cl_Inject------------------------------
// класс инжектор
class Cl_Inject {
    const byte pin;// нога
    const bool inv;// инверсия выхода
    uint32_t *time1, *time2; // указатели на время задержки и времени впрыска
    byte stat = 0; //2(1этап)/1(2этап)/ 0 стоп
    uint32_t past;
  public:
    Cl_Inject(byte _pin, bool _inv, uint32_t *_time1, uint32_t *_time2)
      :        pin(_pin), inv(_inv),   time1(_time1),     time2(_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() {
      stat = 2;
      past = micro;
    }
};
//--------------компоновка----------------------------
uint32_t time1 = 1000; // время задержки впрыска ,микросек
uint32_t time2 = 6000; // время  впрыска  ,микросек
Cl_Inject Inject(/*нога инжектора*/6,/*инвесия вывода*/0,/**/&time1,/**/&time2);
//-------------main()-----------------------------
void setup() {
  Inject.setup();
  Inject.inject();
}

void loop() {
  micro = micros();
  Inject.loop();
}
/*Скетч использует 1154 байт (3%) памяти устройства. Всего доступно 32256 байт.
  Глобальные переменные используют 32 байт (1%) динамической памяти, оставляя 2016 байт для локальных переменных. Максимум: 2048 байт.
*/

Теперь связка Датчик Холла и Инжектор

/**/
uint32_t micro;
//------------Cl_Inject------------------------------
// класс инжектор
class Cl_Inject {
    const byte pin;// нога
    const bool inv;// инверсия выхода
    uint32_t *time1, *time2; // указатели на время задержки и времени впрыска
    byte stat = 0; //2(1этап)/1(2этап)/ 0 стоп
    uint32_t past;
  public:
    Cl_Inject(byte _pin, bool _inv, uint32_t *_time1, uint32_t *_time2)
      :        pin(_pin), inv(_inv),   time1(_time1),     time2(_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() {
      stat = 2;
      past = micro;
    }
};
//-----------------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;
      }
    }
};
//--------------компоновка----------------------------
uint32_t time1 = 1000; // время задержки впрыска ,микросек
uint32_t time2 = 6000; // время  впрыска  ,микросек
Cl_Inject Inject(/*нога инжектора*/6,/*инвесия вывода*/0,/**/&time1,/**/&time2);
void Do_Hall() {
  Inject.inject();
}
Cl_Hall Hall(/*нога датчика*/2,/*инвесия ввода*/0,/*обработчик*/Do_Hall);
//-------------main()-----------------------------
void setup() {
  Inject.setup();
  Hall.setup();
}

void loop() {
  micro = micros();
  Inject.loop();
  Hall.loop();
}
/*Скетч использует 1460 байт (4%) памяти устройства. Всего доступно 32256 байт.
  Глобальные переменные используют 38 байт (1%) динамической памяти, оставляя 2010 байт для локальных переменных. Максимум: 2048 байт.
*/

Теперь подключу еще и переменник 

/**/
uint32_t micro, mill; // переменные для micros() и millis()
//------------Cl_Inject------------------------------
// класс инжектор
class Cl_Inject {
    const byte pin;// нога
    const bool inv;// инверсия выхода
    uint32_t *time1, *time2; // указатели на время задержки и времени впрыска
    byte stat = 0; //2(1этап)/1(2этап)/ 0 стоп
    uint32_t past;
  public:
    Cl_Inject(byte _pin, bool _inv, uint32_t *_time1, uint32_t *_time2)
      :        pin(_pin), inv(_inv),   time1(_time1),     time2(_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() {
      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;
      }
    }
};
//--------------компоновка----------------------------
uint32_t time1 = 1000; // время задержки впрыска ,микросек
uint32_t time2 = 6000; // время  впрыска  ,микросек
Cl_Inject Inject(/*нога инжектора*/6,/*инвесия вывода*/0,/**/&time1,/**/&time2);
Cl_Potentiometer Potentiometer(/*пин потенциометра*/A0,/*переменая*/&time2);// подключить потенциометр
void Do_Hall() {
  Inject.inject();
}
Cl_Hall Hall(/*нога датчика*/2,/*инвесия ввода*/0,/*обработчик*/Do_Hall);
//-------------main()-----------------------------
void setup() {
  Inject.setup();
  Potentiometer.setup();
  Hall.setup();
}

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

ПС: если будет все впорядке соберу на основе этого связку из 4 инжекторов ,2-х датчиков Холла и переменника.

Только есть проблемма, камень делает все последовательно.Поэтому стараюсь задействовать самое необходимое.Графиками и прочим должен заниматся другой камень и возможно даже два.Даже в моем допотопном ЭБУ два блока один исполняет другой обробатывает,хотя выход на форсунки один.

 

перепишу свои программы #184  . Время до впрыска и время впрыска при команде запоминается.

/**/
uint32_t micro;
//------------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;
    }
};
//--------------компоновка----------------------------
uint32_t time1 = 1000; // время задержки впрыска ,микросек
uint32_t time2 = 6000; // время  впрыска  ,микросек
Cl_Inject Inject(/*нога инжектора*/6,/*инвесия вывода*/0,/**/&time1,/**/&time2);
//-------------main()-----------------------------
void setup() {
  Inject.setup();
  Inject.inject();
}

void loop() {
  micro = micros();
  Inject.loop();
}
/*Скетч использует 1218 байт (3%) памяти устройства. Всего доступно 32256 байт.
  Глобальные переменные используют 40 байт (1%) динамической памяти, оставляя 2008 байт для локальных переменных. Максимум: 2048 байт.
*/

Второй скетч

/**/
uint32_t micro;
//------------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_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;
      }
    }
};
//--------------компоновка----------------------------
uint32_t time1 = 1000; // время задержки впрыска ,микросек
uint32_t time2 = 6000; // время  впрыска  ,микросек
Cl_Inject Inject(/*нога инжектора*/6,/*инвесия вывода*/0,/**/&time1,/**/&time2);
void Do_Hall() {
  Inject.inject();
}
Cl_Hall Hall(/*нога датчика*/2,/*инвесия ввода*/0,/*обработчик*/Do_Hall);
//-------------main()-----------------------------
void setup() {
  Inject.setup();
  Hall.setup();
}

void loop() {
  micro = micros();
  Inject.loop();
  Hall.loop();
}
/*Скетч использует 1504 байт (4%) памяти устройства. Всего доступно 32256 байт.
  Глобальные переменные используют 46 байт (2%) динамической памяти, оставляя 2002 байт для локальных переменных. Максимум: 2048 байт.
*/

третий 

/**/
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;
      }
    }
};
//--------------компоновка----------------------------
uint32_t time1 = 1000; // время задержки впрыска ,микросек
uint32_t time2 = 6000; // время  впрыска  ,микросек
Cl_Inject Inject(/*нога инжектора*/6,/*инвесия вывода*/0,/**/&time1,/**/&time2);
Cl_Potentiometer Potentiometer(/*пин потенциометра*/A0,/*переменая*/&time2);// подключить потенциометр
void Do_Hall() {
  Inject.inject();
}
Cl_Hall Hall(/*нога датчика*/2,/*инвесия ввода*/0,/*обработчик*/Do_Hall);
//-------------main()-----------------------------
void setup() {
  Inject.setup();
  Potentiometer.setup();
  Hall.setup();
}

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

 

Ну и наконец код на 4 инжектора и 2 датчика холла, 1 запускает инжекию 2 сбрасывает что бы инжектировал 1 инжектор.

/*
  ардуино пин A0 <--> средний вывод потенциометра
  ардуино пин 2 <--> датчик холла 1 запуск инжектора на каждый горшок
  ардуино пин 3 <--> датчик холла 2 установка 1 горшка
  ардуино пин 6 <--> инжектор 1
  ардуино пин 7 <--> инжектор 2
  ардуино пин 8 <--> инжектор 3
  ардуино пин 9 <--> инжектор 4
*/
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; // номер инжектора для текущей инжекции
  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() {
      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;
      }
    }
    void clear() {
      num = 0;
    }
};
//--------------компоновка----------------------------
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();
}
//-------------main()-----------------------------
void setup() {
  Potentiometer.setup();
  Hall2_Inject4.setup();
}

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

ПС: компилируется . А вот работает или нет не скажу. 

Гдет ошибка работает только один.

А что делает первый холл.Может он не просто сбрасывает но и както блокирует.У меня тоже также получается,что он или включает первый или неработает вообще не один а компилятор пропускает.

Но в твоем скетче инверсию меняеш работает один..или не одного.Ошибка с переменной скорее или со счетчиком.

Да еще потециометр в компорте не изменяет значения.

Да еще потециометр в компорте не изменяет значения.

qwone давай сделаем так, начнем с ядра программы.Уберем датчик ВМТ и потенциометр мы же не знаем как работают инжектора может они не работают.Проверить я могу сразу у меня все на столе.В моем скетче я могу уверенно сказать работают или нет,и что я что то неправельно делаю с датчиком ВМТ.

Ок. Что в ядро программы входит. И что ядро программы делает?

 

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

В 194-ом посте :))))

Если я правельно прочел код то в коде Cl_Hall инвертируются датчики,или только один который упровляет инжекторами?.

Да я для промышленого программирования ставлю эту фичу- инверсия входов и выходов , что бы при отладке не бегать по всей программе. В общем код здесь. Забыл строку переключающую горшки написать. Сюда вставил.

/*
  ардуино пин A0 <--> средний вывод потенциометра
  ардуино пин 2 <--> датчик холла 1 запуск инжектора на каждый горшок
  ардуино пин 6 <--> инжектор 1
  ардуино пин 7 <--> инжектор 2
  ардуино пин 8 <--> инжектор 3
  ардуино пин 9 <--> инжектор 4
*/
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_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_Hall_Inject4-----------------------------------------
// класс из датчикa Холла и 4-x инжекторов
class Cl_Hall_Inject4 {
    Cl_Hall Hall_1;
    Cl_Inject Inject1, Inject2, Inject3, Inject4;
    byte num = 0; // номер инжектора для текущей инжекции
  public:
    Cl_Hall_Inject4(byte _pin1, bool _invH, void (*_Do1)(),
                    byte _pin3, byte _pin4, byte _pin5, byte _pin6, bool _invI, uint32_t *_pnt_time1, uint32_t *_pnt_time2)
      : Hall_1(_pin1, _invH, _Do1),
        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();
      Inject1. setup();
      Inject2. setup();
      Inject3. setup();
      Inject4. setup();
    }
    void loop() {
      Hall_1. 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;
    }
};
//--------------компоновка----------------------------
uint32_t time1 = 1000; // время задержки впрыска ,микросек
uint32_t time2 = 6000; // время  впрыска  ,микросек
void Do_Inject();
Cl_Hall_Inject4  Hall_Inject4(/*нога датчика*/2,/*инвесия ввода*/0,/*обработчик1*/Do_Inject,
    /*нога инжектора1*/6,/*нога инжектора2*/7,/*нога инжектора3*/8,/*нога инжектора4*/9,/*инвесия вывода*/0,/**/&time1,/**/&time2);
void Do_Inject() {
  Hall_Inject4.inject();
}
//-------------main()-----------------------------
void setup() {
  Hall_Inject4.setup();
}

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

 

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

Так и есть строка.Тоже тип топ работает.

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