Arduino.ru

http://microsin.net/adminstuff/hardware/power-mosfet-tutorial.html

У него, походу. вообще нет привязки к датчику - оно "не заработало", там "нужны таблицы и графики" - а это сложно... так что он просто открывает форсунки на 1 мс один раз в 25мс и все

4 СМД чуда припоял завтра буду пробовать, дадут они мне 1 милисекунду или на микросекунду могут выйти.

Сигнал беру с распредвала на нем 4 холла повесил.Что за тупость сигнал с тахометра брать.

Еще чуть скеч доработать, и движок таки сам начнет мироточить бензином. 

впрыск уменьшить с 160 мс до 1 мкс, как мечтает автор - экономия в 160 тыс раз!

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

Ну во первых впрыск работает на 2 милисикундах примерно(тахометр не работает) до 4000 оборотов сегодня пробовал.А 1 милисекунда это не предел можно и в микры перейти похоже форсунки на пределе в холостую работают а под давлением сил открытся нету надо другие искать.

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

Ответе лучше на вопрос через ком порт одновременно можно следить за всеми датчиками одновременно.

Это точно. Уверен, что на практике там никакими 1 мс и не пахнет - форсунки открываются и закрываются как и прежде, на десятки и сотни миллисекунд, просто у тебя нет приборов, чтобы это измерить. Критерий прост - если не получишь снижения расхода хотя бы в 10 раз - значит скетч нифига не работает.

можно, конечно, если программировать умеешь

Програмно  меня устоновленно 1 милисикунда а в чем я уверен то что у меня 15 ОМ форсы и в холостую они срабатывают 350 микросекунд не мили а вот под нагрузкой 1-1.5 милисикунды еле тянут на 2 стабильная работа 

И еще возми калькулятор и посчитай за какое время делает каленвал 2 оборота там сотнями не пахнет 160 мл на холостом и 13.3333333мл на 9 т. А если будет 13.4 то попращайся со своими форсами через несколько минут.

Так как они перестанут закрыватся и сгорят.

160 милисекунд 4 такта тоесть впуск длится 40 милисикунд и то в конце и в начале клапан закрыт какие сотни???

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

Еще раз - для тупых. Если бы у тебя мотор мог бы работать на форсунках , открытых 1 мс вместо 160 мс - у тебя расход упал бы в 100 раз. А этого у тебя нет, и уверен - никогда не будет. Значит в твоих расчетах ошибка

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

Как может быть ошибка в работе самого двигателя?Я его завел и он работает.И еще раз повторяю электронная форсунка это не механическая она должна отдыхать большее время чем работать иначе сгорит.

А расход на ХХ для к -джетроника это и есть проблема .Когда стоиш больше расход больше.Ездиш больше расход меньше.Арасход на ХХ действительно упадет в 100 раз.

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

Нобелевскую премию в студию! :)

Больше стоишь - больше расход - это верно для любой машины. Купи себе учебник арифметики для второго класса....

Не так 

Надо писать Гугл в помощь....

А если стоять с выключенным зажиганием?

Не всегда это возможно, зачем выключать двигатель на 30 секунд ведь пуск движка сожрет столькоже.Но если уменьшить расход на ХХ то за месяц можно хорошо сэкономить. 

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

http://www.oldmerin.net/board/index.php?showtopic=215706

У меня к-джетроник вообще не каких датчиков электрических или электронных нет кроме прогрева .

На 102 ке-джетроник подача топлива регулируется через ЭБУ уже все на датчиках. но форсы механические.

Теперь понятно, я то думал зачем вставить датчик холла так как TD сигнал и так дает тот же сигнал 

Думаю вам поможет для более грамотный настройки топлива 

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

Yer, почему было не вставить ПДФ, если источник в нем? Вы думаете, кто-то станет ломать глаза, рассматривая скрин-шоты?

Я конечно некрасиво влезу в ветку но на сколько мне известно на 124 любые попытки привести в чувство KJ Troniс заканчиваются групповым суицидом всех кто к этому причастен ))) Может стоит подумать о экономии нервов и поставить январь какойнибудь? Так по идее проще должно быть в разы.... 

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

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

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

Инжектор стоит и работает ввопрос в том как его обвешать как мне нужно убрать расход(на данный момент он 7-9 литров), а на январе пусть катаются т(В)АЗы.Да и турбину чтоб поставить надо ЭБУ обкатывать к-джетроник нет. 

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

/*
  ардуино пин A13 <--> средний вывод потенциометра нагрузки
  ардуино пин A14 <--> на вывод термистора прогрева
  ардуино пин A15 <--> средний вывод потенциометра холостого хода
  ардуино пин 5 <--> датчик холла 1 запуск инжектора на каждый горшок
  ардуино пин 6 <--> датчик холла 2 установка 1 горшка
  ардуино пин 22 <--> инжектор 1
  ардуино пин 30 <--> инжектор 2
  ардуино пин 38 <--> инжектор 3
  ардуино пин 46 <--> инжектор 4
  Запуск системы через 2 секунды.
   подготовка еще 0,2 секунды - все инжекторы работают
*/

uint32_t micro, mill; // переменные для micros() и millis()
//--------------------Cl_Idling---------------------------------------------
// класс холостого хода
class Cl_Idling {
    const byte _pin;
    uint32_t *const _pntIdling;// указатель переменную которая меняет значение холостого хода по положению ручки потенциометра
    uint32_t past = 0;
  public:
    Cl_Idling(byte pin, uint32_t *pntIdling): _pin(pin), _pntIdling(pntIdling) {}
    void setup() {
    //  Serial.begin(9600);
      *_pntIdling = map(analogRead(_pin), 0, 1023, 1, 80);//<--- здесь функция поворота ручки в значение холостого хода
    }
    void loop() {
    ////    Serial.print("XolostoiX");
      if (mill - past > 5) {
        *_pntIdling = map(analogRead(_pin), 0, 1023, 1, 80);//<--- здесь функция поворота ручки в значение холостого хода
       //   Serial.print("\t");              // выводим tab
            
      }
           
    }
};
//--------------------Cl_Temp---------------------------------------------
// класс измерителя температуры
class Cl_Temp {
    const byte _pin;
    int *const _pntTemp;// указатель переменную которая меняет значение температуры по положению ручки потенциометра
    int *const _pntTime;// указатель переменную которая меняет значение времени по положению ручки потенциометра
    uint32_t past = 0;
  public:
    Cl_Temp(byte pin, int *pntTemp): _pin(pin), _pntTemp(pntTemp) {}
    void setup() {
     // Serial.begin(9600);
      *_pntTime = _pntTemp + map(analogRead(_pin), 0, 1023, 0, 80);//<--- здесь функция поворота ручки в значение температуры
    }
    void loop() {
       // Serial.print("Temperatura");
      if (millis() - past > 5) {
        *_pntTime = _pntTemp + map(analogRead(_pin), 0, 1023, 0, 80);//<--- здесь функция поворота ручки в значение температуры
       }
        // Serial.print("\t");              // выводим tab
    }
         
};/*
//--------------------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 > 3) {
        *_pntTime = _pntTemp + map(analogRead(_pin), 0, 1023, 0, 0); //<--- здесь функция поворота ручки в значение
      }
    }
};*/
//------------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() {
     // Serial.begin(9600);
      pinMode(pin, OUTPUT);
      stat = 0;
      digitalWrite(pin, inv); // выключить инжектор
    }
    void loop() {
      //  Serial.print("Injector");
      if (stat == 2 && mill - past >= time1) { // если подошло время включить инжектор
        stat = 1;
        past = mill;
        digitalWrite(pin, !inv); // то включить инжектор
      }
      if (stat == 1 && mill - past >= time2) { // если подошло время выключить инжектор
        stat = 0;
        digitalWrite(pin, inv); // то выключить инжектор
      }
      //  Serial.print("\t");              // выводим tab
    }
    void inject() {
      time1 = *pnt_time1;
      time2 = *pnt_time2;
      
      stat = 2;
      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() {
     // Serial.begin(9600);
      pinMode(pin, INPUT);
      Hall_old = digitalRead(pin)^inv;
    }
    void loop() {
    //    Serial.print("Hall");
      Hall = digitalRead(pin)^inv;
      if (Hall && !Hall_old ) {
        Hall_old = 1;
        Do();
      }
      if (!Hall && Hall_old ) {
        Hall_old = 0;
      }
    //    Serial.print("\t");              // выводим tab
    }
        
};
//----------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() {
    //  Serial.begin(9600);
      Hall_1. setup();
      Hall_2. setup();
      Inject1. setup();
      Inject2. setup();
      Inject3. setup();
      Inject4. setup();
    }
    void loop() {
    //    Serial.print("H/I");
      if (stat == 0) return;
      Hall_1. loop();
      Hall_2. loop();
      Inject1. loop();
      Inject2. loop();
      Inject3. loop();
      Inject4. loop();
    //    Serial.print("\t");              // выводим tab
    }
    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)();
      }
    }
};
//--------------компоновка----------------------------
int temp = 0; // температура
uint32_t time1 = 3; // время задержки впрыска 
uint32_t time2 = 1; // время  впрыска  
Cl_Temp Temp(/*пин потенциометра*/A14,/*переменая*/&temp);// подключить термометр
Cl_Idling Idling(/*пин потенциометра*/A15,/*переменая*/&time2);// подключить потенциометр холостого хода
//Cl_Potentiometer Potentiometer(/*пин потенциометра*/A13,/*переменая*/&time2);// подключить потенциометр
void Do_Inject();
void Do_Clear();
Cl_Hall2_Inject4  Hall2_Inject4(/*нога датчика*/5,/*нога датчика*/6,/*инвесия ввода*/1,/*обработчик1*/Do_Inject,/*обработчик2*/Do_Clear,
    /*нога инжектора1*/22,/*нога инжектора2*/30,/*нога инжектора3*/38,/*нога инжектора4*/46,/*инвесия вывода*/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 сек*/1000, // подготовка
  /*обработчик*/Do2_Delay);                         // работа
//-------------main()-----------------------------
void setup() {
  
 // Serial2.begin(9600);
 // Serial3.begin(9600);
  Temp.setup();
  Idling.setup();
 // Potentiometer.setup();
  Hall2_Inject4.setup();
}
void loop() {
  micro = micros();
  mill = millis();
  Temp.loop();
  Idling.loop();
 // Potentiometer.loop();
  Hall2_Inject4.loop();
  Delay.loop();
 // Serial.println(temp);
 // Serial2.println(time1);
 // Serial3.println(time2);

//for(x=0; x< 64; x++){    // выводим печатные символы ASCII
 
   //  delay(500); 
  // Serial.println("");      // еще перенос строки
   
}

решил переделать под 4 датчика

qwone у меня получаются не правельные пчелы и они не делают мед совсем.Компилятор пропускает но ни чего не происходит.

uint32_t micro, mill; // переменные для micros() и millis()
/*
//--------------------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_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_Comutator------------------------------
// класс Comutator
class Cl_Comutator {
    const byte pin;// нога
    const bool inv;// инверсия выхода
    uint32_t *pnt_time4, *pnt_time3; // указатели на время задержки и времени Comutator
    uint32_t time4, time3; // время задержки и времени Comutator
    byte stat = 0; //2(1этап)/1(2этап)/ 0 стоп
    uint32_t past;
  public:
    Cl_Comutator(byte _pin, bool _inv, uint32_t *_pnt_time4, uint32_t *_pnt_time3)
      :        pin(_pin), inv(_inv),   pnt_time4(_pnt_time4),     pnt_time3(_pnt_time3) {}
    void setup() {
      pinMode(pin, OUTPUT);
      stat = 0;
      digitalWrite(pin, inv); // выключить Comutator
    }
    void loop() {
      if (stat == 2 && micro - past >= time4) { // если подошло время включить Comutator
        stat = 1;
        past = micro;
        digitalWrite(pin, !inv); // то включить Comutator
      }
      if (stat == 1 && micro - past >= time3) { // если подошло время выключить Comutator
        stat = 0;
        digitalWrite(pin, inv); // то выключить Comutator
      }
    }
    void Comutator() {
      time4 = *pnt_time4;
      time3 = *pnt_time3;
      stat = 2;
      past = micro;
    }
};
//-----------------Cl_Hall---------------------------------
// класс датчика Холла
class Cl_Hall {
    const byte pin;// нога
    const bool inv;// инверсия выхода
    bool Hall, Hall_old;
  public:
    Cl_Hall(byte _pin, bool _inv)
      :      pin(_pin), inv(_inv)  {}
    void setup() {
      pinMode(pin, INPUT);
      Hall_old = digitalRead(pin)^inv;
    }
    void loop() {
      Hall = digitalRead(pin)^inv;
      if (Hall && !Hall_old ) {
        Hall_old = 1;
      }
      if (!Hall && Hall_old ) {
        Hall_old = 0;
      }
    }
};

//--------------компоновка----------------------------
uint32_t time1 = 1000; // время задержки впрыска ,микросек
uint32_t time2 = 6000; // время  впрыска  ,микросек

uint32_t time3 = 1000; // время задержки впрыска ,микросек
uint32_t time4 = 6000; // время  впрыска  ,микросек

Cl_Hall Hall1(/*нога датчика*/8,/*инвесия ввода*/0);
Cl_Hall Hall2(/*нога датчика*/9,/*инвесия ввода*/0);
Cl_Hall Hall3(/*нога датчика*/10,/*инвесия ввода*/0);
Cl_Hall Hall4(/*нога датчика*/11,/*инвесия ввода*/0);

Cl_Inject Inject1(/*нога инжектора*/22,/*инвесия вывода*/0,/**/&time1,/**/&time2);
Cl_Inject Inject2(/*нога инжектора*/23,/*инвесия вывода*/0,/**/&time1,/**/&time2);
Cl_Inject Inject3(/*нога инжектора*/25,/*инвесия вывода*/0,/**/&time1,/**/&time2);
Cl_Inject Inject4(/*нога инжектора*/24,/*инвесия вывода*/0,/**/&time1,/**/&time2);

Cl_Comutator Comutator1(/*нога инжектора*/38,/*инвесия вывода*/0,/**/&time4,/**/&time3);
Cl_Comutator Comutator2(/*нога инжектора*/46,/*инвесия вывода*/0,/**/&time4,/**/&time3);
Cl_Comutator Comutator3(/*нога инжектора*/38,/*инвесия вывода*/0,/**/&time4,/**/&time3);
Cl_Comutator Comutator4(/*нога инжектора*/46,/*инвесия вывода*/0,/**/&time4,/**/&time3);

//Cl_Potentiometer Potentiometer(/*пин потенциометра*/A0,/*переменая*/&time2);// подключить потенциометр


//-------------main()-----------------------------
void setup() {
  Comutator1.setup();
Comutator2.setup();
Comutator3.setup();
Comutator4.setup();  
  Inject1.setup();
  Inject2.setup();
  Inject3.setup();  
  Inject4.setup();
 // Potentiometer.setup();
  Hall1.setup();
  Hall2.setup();
  Hall3.setup();
  Hall4.setup();  
}

void loop() {
  micro = micros();
  mill = millis();
  Comutator1.loop();
  Comutator2.loop();
  Comutator3.loop();
  Comutator4.loop();  
  Inject1.loop();
  Inject2.loop();
  Inject3.loop();
  Inject4.loop();  
 // Potentiometer.loop();
  Hall1.loop();
  Hall2.loop();
  Hall3.loop();
  Hall4.loop();  
}

чтото я упустил,где ошибка?

Может так 

//--------------------Cl_Idling---------------------------------------------
// класс холостого хода
class Cl_Idling {
    const byte _pin;
    uint32_t *const _pntIdling;// указатель переменную которая меняет значение холостого хода по положению ручки потенциометра
    uint32_t past = 0;
  public:
    /*конструктор:Cl_Idling
      описание: оздает объект класса
      ввод:  pin: -нога  для подключения потенциометра
              pntIdling: указатель на переменную которую меняют
      вывод;
    */
    Cl_Idling(byte pin, uint32_t *pntIdling): _pin(pin), _pntIdling(pntIdling) {}
    /*конструктор:setup
      описание:для нормальной работы класса вставьте в setup программы
      ввод:   нет
      вывод;  нет
    */
    void setup() {
      *_pntIdling = map(analogRead(_pin), 0, 1023,/*min*/ 1,/*max*/ 80);//min, max пределы регулирования
    }
    /*функция :loop
      описание:для нормальной работы класса вставьте в loop программы
      ввод:   нет
      вывод;  нет
    */
    void loop() {
      if (mill - past >=/*время*/5) {// время опроса в миллисек
        past = mill; //<---здесь должна быть такая строчка
        *_pntIdling = map(analogRead(_pin), 0, 1023,/*min*/ 1,/*max*/ 80);//min, max пределы регулирования
      }
    }
};

ПС: А такая конструкция должна быть более быстрее

/**/
unsigned long mill;
//-----Cl_Tuk-----------------------
class Cl_Tuk {
    unsigned long time;
    unsigned long past = 0;
  public:
    Cl_Tuk(unsigned long _time): time(_time) {}
    void setup() {}
    void loop() {
      if (mill - past >= time) {
        past = mill;
        Serial.println("Tuk");
      }
    }
};
//----Компоновка------------------------
const unsigned long time_1s = 1000;
Cl_Tuk Tuk(/*время*/time_1s);
//-----main-----------------------
int main() {
  init();
  // setup
  Serial.begin(9600);
  for (;;) {
    // loop
    mill = millis();
    Tuk.loop();
  }
  return 0;
}
/*Скетч использует 1514 байт (4%) памяти устройства. Всего доступно 32256 байт.
  Глобальные переменные используют 202 байт (9%) динамической памяти, оставляя 1846 байт для локальных переменных. Максимум: 2048 байт.
*/

//--------------------Cl_Idling---------------------------------------------
// класс холостого хода
class Cl_Idling {
    const byte _pin;
    uint32_t *const _pntIdling;// указатель переменную которая меняет значение холостого хода по положению ручки потенциометра
    uint32_t past = 0;
  public:
    /*конструктор:Cl_Idling
      описание: оздает объект класса
      ввод:  pin: -нога  для подключения потенциометра
              pntIdling: указатель на переменную которую меняют
      вывод;
    */
    Cl_Idling(byte pin, uint32_t *pntIdling): _pin(pin), _pntIdling(pntIdling) {}
    /*конструктор:setup
      описание:для нормальной работы класса вставьте в setup программы
      ввод:   нет
      вывод;  нет
    */
    void setup() {
      *_pntIdling = map(analogRead(_pin), 0, 1023,/*min*/ 1,/*max*/ 80);//min, max пределы регулирования
    }
    /*функция :loop
      описание:для нормальной работы класса вставьте в loop программы
      ввод:   нет
      вывод;  нет
    */
    void loop() {
      if (mill - past >=/*время*/5) {// время опроса в миллисек
        past = mill; //<---здесь должна быть такая строчка
        *_pntIdling = map(analogRead(_pin), 0, 1023,/*min*/ 1,/*max*/ 80);//min, max пределы регулирования
      }
    }
};

/**/
unsigned long mill;
//-----Cl_Tuk-----------------------
class Cl_Tuk {
    unsigned long time;
    unsigned long past = 0;
  public:
    Cl_Tuk(unsigned long _time): time(_time) {}
    void setup() {}
    void loop() {
      if (mill - past >= time) {
        past = mill;
        Serial.println("Tuk");
      }
    }
};
//----Компоновка------------------------
const unsigned long time_1s = 1000;
Cl_Tuk Tuk(/*время*/time_1s);
//-----main-----------------------
int main() {
  init();
  // setup
  Serial.begin(9600);
  for (;;) {
    // loop
    mill = millis();
    Tuk.loop();
  }
  return 0;
}
/*Скетч использует 1514 байт (4%) памяти устройства. Всего доступно 32256 байт.
  Глобальные переменные используют 202 байт (9%) динамической памяти, оставляя 1846 байт для локальных переменных. Максимум: 2048 байт.
*/

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

Я заливал код на 2 датчика холла и 4 инжектора он от скачков напрежения или замыкания виснит.Начинает работать сам. Движок стоит а инжектора включаются сами по себе.

Я не стал разбиратся в этом и решил переделать всетаки на 4 холла и 4 инжектора + 2 комутатора зажигания .

Так работает чем и пока пользуюсь

/*
  порядок 1-3-2-4
  под мега 2560
  ардуино пин A13 <--> средний вывод потенциометра нагрузки  
  ардуино пин A14 <--> на вывод термистора // cчитаем еще один потенциометр
  ардуино пин A15 <--> средний вывод потенциометра холостой ход
  расчет потенциометров-холостой ход + нагрузка + прогрев 
                        холостой ход + прогрев без нагрузки
                        холостой ход + нагрузка без прогревa
  ардуино пин 8 <--> датчик холла 1
  ардуино пин 9 <--> датчик холла 3
  ардуино пин 10 <--> датчик холла 2
  ардуино пин 11 <--> датчик холла 4
  ардуино пин 22 <--> инжектор 1
  ардуино пин 23 <--> инжектор 3
  ардуино пин 24 <--> инжектор 2
  ардуино пин 25 <--> инжектор 4
  ардуино пин 26 <--> катушка 1
  ардуино пин 27 <--> катушка 2
*/
uint32_t micro, mill; // переменные для micros() и millis()
/*
//--------------------Cl_Potentiometer---------------------------------------------
// класс потемциометр . Меняет значение внешней переменной в зависимости от ручки потенциометра
class Cl_Potentiometer {
    const byte _pin;
    uint32_t *const _pntTemp;// указатель переменную которая меняет значение температуры по положению ручки потенциометра(входящее значение)
    uint32_t *const _pntTime;// указатель переменную которая меняет значение времени по положению ручки потенциометра
    uint32_t past = 0;
  public:
    Cl_Potentiometer(byte pin, uint32_t *pntTemp, uint32_t *pntTime): _pin(pin), _pntTemp(pntTemp), _pntTime(pntTime) {}
    void setup() {
      * _pntTime = _pntTemp + map(analogRead(_pin), 0, 1023, 0, 2000); //<--- здесь функция поворота ручки в значение
    }
    void loop() {
      if (micro - past > 1) {
        *_pntTime = _pntTemp + map(analogRead(_pin), 0, 1023, 0, 2000); //<--- здесь функция поворота ручки в значение
      }
    }
};

//--------------------Cl_Temp---------------------------------------------
// класс измерителя температуры
class Cl_Temp {
    const byte _pin;
    uint32_t *const _pntTemp;// указатель переменную которая меняет значение температуры по положению ручки потенциометра
    byte past = 0;
  public:
 Cl_Temp(byte pin, uint32_t *pntTemp): _pin(pin), _pntTemp(pntTemp) {}
    void setup() {
      *_pntTemp = map(analogRead(_pin), 0, 1023, 3000, 0);//<--- здесь функция поворота ручки в значение температуры
    }
    void loop() {
      if (micro - past > 1) {
        *_pntTemp = map(analogRead(_pin), 0, 1023, 3000, 0);//<--- здесь функция поворота ручки в значение температуры
      }
    }
};*/
//--------------------Cl_XolostoiXod---------------------------------------------
// класс холостого хода
class Cl_XolostoiXod {
    const byte _pin;   
    uint32_t *const _pntXolostoiXod;// указатель переменную которая меняет значение холостого хода по положению ручки потенциометра
    uint32_t past = 0;
  public:    Cl_XolostoiXod(byte pin, uint32_t *pntXolostoiXod)
    : _pin(pin), _pntXolostoiXod(pntXolostoiXod) {}
    void setup() {
      *_pntXolostoiXod = map(analogRead(_pin), 0, 1023, 1000, 5000);//<--- здесь функция поворота ручки в значение холостого хода
    }
    void loop() {
      if (micro - past > 1) {
        *_pntXolostoiXod = map(analogRead(_pin), 0, 1023, 1000, 5000);//<--- здесь функция поворота ручки в значение холостого хода
      }
    }
};
//--------------------Cl_HallToInject-------------------------------
// класс Датчик Холла задает начало открытия инжектора
class Cl_HallToInject {
    uint32_t time = 0; // длительность
    uint32_t *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, uint32_t *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 = micro;
      }
      else if (!Hall && Hall_old) {
        Hall_old = 0;
      }
      if (Inject && micro - past >= time) { // если истекло время
        Inject = 0;                            // то выкл Инжектор
        digitalWrite(_Inject_pin, _invI ^ Inject);
      }
    }
};
//--------------------Cl_HallToCamutator-------------------------------
// класс Датчик Холла задает искру
class Cl_HallToCamutator {
    uint32_t time1 = 1000; // длительность 1 milliсекунды
    uint32_t *const _pnt;// указатель переменную которая задает новое значение time
    const byte _Hall_pin  ; // пин холла
    const byte _Camutator_pin;// пин камутатора
    bool Hall, Hall_old;
    bool Camutator;
    bool _invH, _invI; // инверсия выходов датчика Холла и камутатора
    uint32_t past = 0;
  public:
    Cl_HallToCamutator(byte Hall_pin, bool invH, byte Camutator_pin, bool invI, uint32_t *pnt)
      : _Hall_pin(Hall_pin), _invH(invH), _Camutator_pin(Camutator_pin), _invI(invI) , _pnt(pnt) {}
    void setup() {
      pinMode(_Hall_pin, INPUT);
      Hall_old = _invH ^ digitalRead( _Hall_pin);
      pinMode(_Camutator_pin, OUTPUT);
      Camutator = 0;
      digitalWrite(_Camutator_pin, _invI ^ Camutator);
    }
    void loop() {
      Hall = _invH ^ digitalRead( _Hall_pin);
      if (Hall && !Hall_old) { // если сработал датчик Холла
        Hall_old = 1;
        Camutator = 1;            // то вкл камутатор
        digitalWrite(_Camutator_pin, _invI ^ Camutator);
        time1 = *_pnt; // выставить новое время искры
        past = micro;
      }
      else if (!Hall && Hall_old) {
        Hall_old = 0;
      }
      if (Camutator && micro - past >= time1) { // если истекло время
        Camutator = 0;                            // то выкл камутатор
        digitalWrite(_Camutator_pin, _invI ^ Camutator);
      }
    }
};
//------------------Компоновка---------------------------------
uint32_t time1 = 1000; // длительность искры
uint32_t temp = 0; // температура
uint32_t time = 0; // длительность впрыска
Cl_XolostoiXod XolostoiXod(/*пин потенциометра*/A13,/*переменая*/&time);// подключить потенциометр холостого хода
//Cl_Temp Temp(/*пин потенциометра*/A13,/*переменая*/&time);// подключить термометр
//Cl_Potentiometer Potentiometer(/*пин потенциометра*/A15,/* входная переменая*/&temp,/*выходная переменая*/&time);// подключить потенциометр нагрузки
// Замечание: Если вам нужно проинвертировать сигнал, то замените 0 на 1
Cl_HallToInject HallToInject1(/*датчик Холла*/8,/*инверт сиг с датХолла*/1,/*инжектор*/22,/*инверт сиг на инжектор*/0,/*время впрыска*/&time);
Cl_HallToInject HallToInject2(/*датчик Холла*/9,/*инверт сиг с датХолла*/1,/*инжектор*/23,/*инверт сиг на инжектор*/0,/*время впрыска*/&time);
Cl_HallToInject HallToInject3(/*датчик Холла*/10,/*инверт сиг с датХолла*/1,/*инжектор*/25,/*инверт сиг на инжектор*/0,/*время впрыска*/&time);
Cl_HallToInject HallToInject4(/*датчик Холла*/11,/*инверт сиг с датХолла*/1,/*инжектор*/24,/*инверт сиг на инжектор*/0,/*время впрыска*/&time);
Cl_HallToCamutator HallToCamutator1(/*датчик Холла*/8,/*инверт сиг с датХолла*/1,/*инжектор*/38,/*инверт сиг на инжектор*/0,/*время впрыска*/&time1);
Cl_HallToCamutator HallToCamutator2(/*датчик Холла*/9,/*инверт сиг с датХолла*/1,/*инжектор*/46,/*инверт сиг на инжектор*/0,/*время впрыска*/&time1);
Cl_HallToCamutator HallToCamutator3(/*датчик Холла*/10,/*инверт сиг с датХолла*/1,/*инжектор*/38,/*инверт сиг на инжектор*/0,/*время впрыска*/&time1);
Cl_HallToCamutator HallToCamutator4(/*датчик Холла*/11,/*инверт сиг с датХолла*/1,/*инжектор*/46,/*инверт сиг на инжектор*/0,/*время впрыска*/&time1);

//------------------main()---------------------------------
void setup() {
  Serial.begin(9600);
//  RPM.setup();
  //Temp.setup();
  XolostoiXod.setup();
  //Potentiometer.setup();
  HallToInject1.setup();
  HallToInject2.setup();
  HallToInject3.setup();
  HallToInject4.setup();
  HallToCamutator1.setup();
  HallToCamutator2.setup();
  HallToCamutator3.setup();
  HallToCamutator4.setup();
}

void loop() {
  Serial.println(time);
  micro = micros();
  mill = millis();
  XolostoiXod.loop();
  //Temp.loop();
  //Potentiometer.loop();
  HallToInject1.loop();
  HallToInject2.loop();
  HallToInject3.loop();
  HallToInject4.loop();
  HallToCamutator1.loop();
  HallToCamutator2.loop();
  HallToCamutator3.loop();
  HallToCamutator4.loop();
}

 Просто решил переделать 2 холла на 4 холла потому что в этом скатче нет задержки перед впрыском а в том есть.

Можно конечно попробовать вставить,но пока ума не хвотает.

Вобщем такая ситуация когда за коментируешь 3холла 3 инжектора и все камутаторы

1 холл и 1 инжектор работают,раскоментируешь ни чего вообще не работает.

Похоже вам не хватает этого класса. Изменение значения переменной ручкой потенциометра и выводом ее в serial.

/**/
unsigned long mill;
//-----Cl_Regulator-----------------------
// класс регулятор - меняет значение переменной
//в заданых пределах ручкой потенциометра каждые 0.2 сек
class Cl_Regulator {
  protected:
    const byte pin;
    int  *const pVal;
    const int  minVal;
    const int  maxVal;
    const char *const name;
    unsigned long past = 0;
  public:
    Cl_Regulator(byte _pin, int  *_pVal, int  _minVal, int  _maxVal, char *_name)
      :         pin(_pin), pVal(_pVal), minVal(_minVal), maxVal(_maxVal), name(_name) {}
    void setup() {}
    void loop() {
      if (mill - past >= 200) {
        past = mill;
        *pVal = map(analogRead(pin), 0, 1023, minVal, maxVal);
        Serial.print(name);
        Serial.print(*pVal);
        Serial.println();
      }
    }
};
//----Компоновка------------------------
int valA = 100; //регулируемая переменая A
int valB = -300; //регулируемая переменая B
int valC = -300; //регулируемая переменая C
Cl_Regulator Regulator1(/*пин*/A0,/*переменая*/&valA,/*min*/100,/*max*/300,/*имя*/"A=");
Cl_Regulator Regulator2(/*пин*/A1,/*переменая*/&valB,/*min*/ -300,/*max*/ -100,/*имя*/"B=");
Cl_Regulator Regulator3(/*пин*/A2,/*переменая*/&valC,/*min*/ -300,/*max*/300,/*имя*/"C=");
//-----main-----------------------
int main() {
  init();
  // setup
  Serial.begin(9600);
  for (;;) {
    // loop
    mill = millis();
    Regulator1.loop();
    Regulator2.loop();
    Regulator3.loop();
  }
  return 0;
}
/*Скетч использует 2238 байт (6%) памяти устройства. Всего доступно 32256 байт.
  Глобальные переменные используют 243 байт (11%) динамической памяти, оставляя 1805 байт для локальных переменных. Максимум: 2048 байт.
*/

Вот еще один код

/**/
uint32_t micro, mill; // переменные для micros() и millis()
//-----Cl_Regulator-----------------------
// класс регулятор - меняет значение переменной
//в заданых пределах ручкой потенциометра каждые 0.2 сек
class Cl_Regulator {
  protected:
    const byte pin;
    uint32_t  *const pVal;
    const uint32_t  minVal;
    const uint32_t  maxVal;
    const char *const name;
    unsigned long past = 0;
  public:
    Cl_Regulator(byte _pin, uint32_t  *_pVal, uint32_t  _minVal, uint32_t  _maxVal, char *_name)
      :         pin(_pin), pVal(_pVal), minVal(_minVal), maxVal(_maxVal), name(_name) {}
    void setup() {}
    void loop() {
      if (mill - past >= 200) {
        past = mill;
        *pVal = map(analogRead(pin), 0, 1023, minVal, maxVal);
        Serial.print(name);
        Serial.print(*pVal);
        Serial.println();
      }
    }
};
//--------------------Cl_HallToInj-------------------------------
// класс Датчик Холла задает начало открытия инжектора
class Cl_HallToInj {
    uint32_t time = 0; // длительность
    uint32_t *const pTime;// указатель переменную которая задает новое значение time
    const byte hallPin  ; // пин холла
    const byte injPin;// пин инжектора
    bool hall, oldHall;
    bool inj;
    bool invH, invI; // инверсия выходов датчика Холла и инжектора
    uint32_t past = 0;
  public:
    Cl_HallToInj(byte _hallPin, bool _invH, byte _injPin, bool _invI, uint32_t *_pTime)
      : hallPin(_hallPin), invH(_invH), injPin(_injPin), invI(_invI) , pTime(_pTime) {}
    void setup() {
      pinMode(hallPin, INPUT);
      oldHall = digitalRead(hallPin)^invH;
      pinMode(injPin, OUTPUT);
      inj = 0;
      digitalWrite(injPin, inj ^ invI);
    }
    void loop() {
      hall = digitalRead(hallPin)^invH;
      if (hall && !oldHall) { // если сработал датчик Холла
        oldHall = 1;
        inj = 1;            // то вкл Инжектор
        digitalWrite(injPin, invI ^ inj);
        time = *pTime; // выставить новое время впрыска
        past = micro;
      }
      else if (!hall && oldHall) {
        oldHall = 0;
      }
      if (inj && micro - past >= time) { // если истекло время
        inj = 0;                         // то выкл Инжектор
        digitalWrite(injPin, invI ^ inj);
      }
    }
};
//----Компоновка------------------------
uint32_t time = 1000; //время инжекции в микросекундах
Cl_Regulator Regulator1(/*пин*/A0,/*переменая*/&time,/*min*/1000,/*max*/5000,/*имя*/"time=");
Cl_HallToInj HallToInject1(/*датчик Холла*/2,/*инверт сиг с датХолла*/1,/*инжектор*/6,/*инверт сиг на инжектор*/0,/*время впрыска*/&time);
Cl_HallToInj HallToInject2(/*датчик Холла*/3,/*инверт сиг с датХолла*/1,/*инжектор*/7,/*инверт сиг на инжектор*/0,/*время впрыска*/&time);
Cl_HallToInj HallToInject3(/*датчик Холла*/4,/*инверт сиг с датХолла*/1,/*инжектор*/8,/*инверт сиг на инжектор*/0,/*время впрыска*/&time);
Cl_HallToInj HallToInject4(/*датчик Холла*/5,/*инверт сиг с датХолла*/1,/*инжектор*/9,/*инверт сиг на инжектор*/0,/*время впрыска*/&time);
//-----main-----------------------
int main() {
  init();
  // setup
  Serial.begin(9600);
  HallToInject1.setup();
  HallToInject2.setup();
  HallToInject3.setup();
  HallToInject4.setup();
  for (;;) {
    // loop
    mill = millis();
    micro = micros();
    Regulator1.loop();
    HallToInject1.loop();
    HallToInject2.loop();
    HallToInject3.loop();
    HallToInject4.loop();
  }
  return 0;
}
/*Скетч использует 3014 байт (9%) памяти устройства. Всего доступно 32256 байт.
  Глобальные переменные используют 289 байт (14%) динамической памяти, оставляя 1759 байт для локальных переменных. Максимум: 2048 байт.
*/

Что бы это реализовать, нужна точная блоксхема необходимой программы со всеми управляющими сигналами и реакцией на них. У ТС не хватает знаний понять это. Жаль. Пять страниц темы даже не приблизили к результату.

nik182. Ну вы здесь глубоко не правы. Наверно вы знаете про "закон Мура"- ну там где все растет лавинообразно. Но в отличии от железа. Работать программисты по закону Мура не могут. Так что бы освоить весь фунционал контролера приходится переходить на модульность системы, языки высокого уровня. Так что из-за этого Си стал Си++ и в ООП. Но все это преамбула. Посмотрите на камень Ардуины, с которым мы работаем. Он уже перестал быть маленьким. Но и да в этом он уже стал слабым для теперешних хотелок, по памяти и по аппаратной части.  И как вы собираетсь их программировать. Или на пседоклассах- подключаемых файлах библиотек отдельных функций связаных функционалом. Или уже без надувания щек-"не место классов в программировании контролеров" использовать классы при программировании микропроцессоров. 

 ПС: Я не хотел обидить вас. Скорее всего вы программируете МК лучше меня, но без классов уже никуда. Вот только тащить в МК стандартную библиотеку шаблонов рановато. Мелковаты пока МК.

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

В задаче ТС нет ничего такого, что  требовало бы решать ее только через классы.Не надо начинать холивар на тему "процедуры vs ООП" . Смысл сообщения nik182 совсем в другом - проблема этого кода не в реализации, а в том что ТС крайне слабо представляет. чтоже конкретно нужно запрограммировать.

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

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

О прерываниях пока только мысли сейчас все строится на меге2560 и ее хватает.

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

Ну а о том что нет результатов это не в тему, все работает проверенно на авто но требует коррекции и доработки. 

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

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

qwone  до меня еще не доходит как вставить переменную задержки впрыска перед впрыском 

Вот возьми-те стандартную ситуацию. Есть заказчик, у заказчика есть проект и есть вы . Разумеется  вы хотите кушать. Замечательно если проект вылизан и его нужно просто перевести в код. Но если у заказчика только есть хочу. И это хочу он видел на выставке, но платить за это он не хочет. Он хочет платить вам, а вам надо "кушать". Что делать. Поэтому рисуется код макет из той херни, вам дали под названием ТЗ. Код лучше рисовать все же через классы. Потому так все же быстрее. Да и подключать можно уже проверенные наработки. Потом показ. Заказчик понимает что это и то и не то одновременно. Но работа есть , часть денег можно получить.  А вот если уже все отлажено,то можно уже раскрыть классы и переложить на процедуры . Разумеется так программа станет лучше.

А где у меня железо?Это форсунки чтоли?Или потенциометр или датчик температуры?Может камутатор интерестно куда здесь дрова нужны?

Полностью согласен если чтото не нравится можно это заменить не переписывая.