Arduino.ru

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

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

Написать программу для того кто не шарит легко.А вот для того кто шарит и сам написать не может это посложнее будет.А что такое ТЗ?

Может так

/**/
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 timeZ = 0; // длительность задержки впрыска
    uint32_t time = 0; // длительность впрыска
    uint32_t *const pTimeZ;// указатель на длительность задержки впрыска
    uint32_t *const pTime;// указатель на длительность задержки впрыска
    const byte hallPin  ; // пин холла
    const byte injPin;// пин инжектора
    bool hall, oldHall;
    bool statZ = 0; //состояние задержки
    bool inj;
    bool invH, invI; // инверсия выходов датчика Холла и инжектора
    uint32_t past = 0;
  public:
    Cl_HallToInj(byte _hallPin, bool _invH, byte _injPin, bool _invI, uint32_t *_pTimeZ, uint32_t *_pTime)
      :      hallPin(_hallPin), invH(_invH), injPin(_injPin), invI(_invI) , pTimeZ(_pTimeZ), 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;
        statZ = 1;
        timeZ = *pTimeZ; // выставить новое время задержки впрыска
        past = micro;
      }
      else if (!hall && oldHall) {
        oldHall = 0;
      }
      if (statZ && micro - past >= timeZ) {
        statZ = 0;
        inj = 1;            // то вкл Инжектор
        digitalWrite(injPin, invI ^ inj);
        time = *pTime; // выставить новое время впрыска
        past = micro;
      }
      if (inj && micro - past >= time) { // если истекло время
        inj = 0;                         // то выкл Инжектор
        digitalWrite(injPin, invI ^ inj);
      }
    }
};
//----Компоновка------------------------
uint32_t time = 1000; //время инжекции в микросекундах
uint32_t time1 = 1000; //время задержки инжекции в микросекундах
Cl_Regulator Regulator1(/*пин*/A0,/*переменая*/&time,/*min*/1000,/*max*/5000,/*имя*/"time=");
Cl_Regulator Regulator2(/*пин*/A1,/*переменая*/&time1,/*min*/0,/*max*/1000,/*имя*/"time_z=");
Cl_HallToInj HallToInject1(/*датчик Холла*/2,/*инверт сиг с датХолла*/1,/*инжектор*/6,/*инверт сиг на инжектор*/0,/*время задерж.впрыска*/&time1,/*время впрыска*/&time);
Cl_HallToInj HallToInject2(/*датчик Холла*/3,/*инверт сиг с датХолла*/1,/*инжектор*/7,/*инверт сиг на инжектор*/0,/*время задерж.впрыска*/&time1,/*время впрыска*/&time);
Cl_HallToInj HallToInject3(/*датчик Холла*/4,/*инверт сиг с датХолла*/1,/*инжектор*/8,/*инверт сиг на инжектор*/0,/*время задерж.впрыска*/&time1,/*время впрыска*/&time);
Cl_HallToInj HallToInject4(/*датчик Холла*/5,/*инверт сиг с датХолла*/1,/*инжектор*/9,/*инверт сиг на инжектор*/0,/*время задерж.впрыска*/&time1,/*время впрыска*/&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();
    Regulator2.loop();
    HallToInject1.loop();
    HallToInject2.loop();
    HallToInject3.loop();
    HallToInject4.loop();
  }
  return 0;
}
/*Скетч использует 3282 байт (10%) памяти устройства. Всего доступно 32256 байт.
  Глобальные переменные используют 346 байт (16%) динамической памяти, оставляя 1702 байт для локальных переменных. Максимум: 2048 байт.
*/

 ТЗ- техническое задание.документ в котором все четко прописано, что программа должна делать. Вот только когда подходят сроки и программа делает то что написано в ТЗ, а у заказчика появился другой взгляд на результат. Но чаще в ТЗ написана херня.

ТЗ это то что я прошу с начала темы. Тех. задание.

А на каком языке написаны программы в ЭБУ авто?Может вовсе не на Си.

а что это меняет?

Скорость исполнения программой насколько я знаю Си не блещет скоростью.

Во-общето еще веселее. Скетч который выкладывают я на форуме это исходник. Вот по нему компилятор собирает код, который заливают в железо. Чаще всего фирмы прячут исходник у себя, а народу дают код для заливки в компьютер машины. Дрова у меня и есть описание классов. Вот только дрова находятся в подключаемых файлах. А я выкладываю их в основной скетч, что было проще народу с форума с ним работать. Раздел Компановка это поключение железа в вашу программу и их настройка. То что кидается в разделы loop и setup это скорее издержки этого стиля. Иначе там была бы режущая глаз новичку херня.

ПС:nik182 - просто чистый Си-ник. И наличие дров в виде классов коробит его регилиозные чувства.

Си - компилируемый язык. Это значит, что исходный код программы на С и тот машинный код, который загружается в ЭБУ - прямо скажем, разные вещи :)

Из языков высокого уровня - Си один из самых быстрых.

qwone - скажите честно, вы до ардуины, похоже, никогда программированием не занимались? Вы живете в какой-то искаженной "ардуино-матрице"

А вот и ответ один ИЗ....

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

Для меня естественно но для концерна фольксваген может на асемблере проще или даже для ваза.

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

/**/
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 timeZ = 0; // длительность задержки впрыска
    uint32_t time = 0; // длительность впрыска
    uint32_t *const pTimeZ;// указатель на длительность задержки впрыска
    uint32_t *const pTime;// указатель на длительность задержки впрыска
    const byte hallPin  ; // пин холла
    const byte injPin;// пин инжектора
    bool hall, oldHall;
    bool statZ = 0; //состояние задержки
    bool inj;
    bool invH, invI; // инверсия выходов датчика Холла и инжектора
    uint32_t past = 0;
  public:
    Cl_HallToInj(byte _hallPin, bool _invH, byte _injPin, bool _invI, uint32_t *_pTimeZ, uint32_t *_pTime)
      :      hallPin(_hallPin), invH(_invH), injPin(_injPin), invI(_invI) , pTimeZ(_pTimeZ), 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;
        statZ = 1;
        timeZ = *pTimeZ; // выставить новое время задержки впрыска
        past = micro;
      }
      else if (!hall && oldHall) {
        oldHall = 0;
      }
      if (statZ && micro - past >= timeZ) {
        statZ = 0;
        inj = 1;            // то вкл Инжектор
        digitalWrite(injPin, invI ^ inj);
        time = *pTime; // выставить новое время впрыска
        past = micro;
      }
      if (inj && micro - past >= time) { // если истекло время
        inj = 0;                         // то выкл Инжектор
        digitalWrite(injPin, invI ^ inj);
      }
    }
};
//----Компоновка------------------------
uint32_t time = 1000; //время инжекции в микросекундах
uint32_t time1 = 1000; //время задержки инжекции в микросекундах
Cl_Regulator Regulator1(/*пин*/A0,/*переменая*/&time,/*min*/1000,/*max*/5000,/*имя*/"time=");
Cl_Regulator Regulator2(/*пин*/A1,/*переменая*/&time1,/*min*/0,/*max*/1000,/*имя*/"time_z=");
Cl_HallToInj HallToInject1(/*датчик Холла*/2,/*инверт сиг с датХолла*/1,/*инжектор*/6,/*инверт сиг на инжектор*/0,/*время задерж.впрыска*/&time1,/*время впрыска*/&time);
Cl_HallToInj HallToInject2(/*датчик Холла*/3,/*инверт сиг с датХолла*/1,/*инжектор*/7,/*инверт сиг на инжектор*/0,/*время задерж.впрыска*/&time1,/*время впрыска*/&time);
Cl_HallToInj HallToInject3(/*датчик Холла*/4,/*инверт сиг с датХолла*/1,/*инжектор*/8,/*инверт сиг на инжектор*/0,/*время задерж.впрыска*/&time1,/*время впрыска*/&time);
Cl_HallToInj HallToInject4(/*датчик Холла*/5,/*инверт сиг с датХолла*/1,/*инжектор*/9,/*инверт сиг на инжектор*/0,/*время задерж.впрыска*/&time1,/*время впрыска*/&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();
    Regulator2.loop();
    HallToInject1.loop();
    HallToInject2.loop();
    HallToInject3.loop();
    HallToInject4.loop();
  }
  return 0;
}
/*Скетч использует 3282 байт (10%) памяти устройства. Всего доступно 32256 байт.
  Глобальные переменные используют 346 байт (16%) динамической памяти, оставляя 1702 байт для локальных переменных. Максимум: 2048 байт.
*/

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

А  вот с тахометра начнется вот такое кино

А теперь осталось построить график. Время задержки впрыска(TimeZ) от времени между впрысками в микросекундах.

График это не так сложно он есть ,как впишится все это в программу не будет ли тормоза или прога слетать или виснуть?

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

Вот вам это вместо тахогенератора. повесите на датчик Холла 

/**/
uint32_t micro, mill; // переменные для micros() и millis()
//-----Cl_observer-----------------------
// класс обозреватель - показывает значение переменной каждые 0.2 сек
//в заданых пределах ручкой потенциометра каждые 0.2 сек
class Cl_observer {
  protected:
    uint32_t *const  pVal;// указатель на нужную переменную
    const char *name;
    uint32_t past = 0;
  public:
    Cl_observer(uint32_t  *_pVal, char *_name) :  pVal(_pVal), name(_name) {}
    void setup() {}
    void loop() {
      if (mill - past >= 200) {
        past = mill;
        Serial.print(name);
        Serial.print(*pVal);
        Serial.println();
      }
    }
};
//--------------------Cl_periodMeter-------------------------------
// класс Датчик Холла задает начало открытия инжектора
class Cl_periodMeter {
    const byte pin;
    uint32_t *const pVal;// указатель на нужную переменную
    bool hall , oldHall;
    uint32_t past = 0;
  public:
    Cl_periodMeter(byte _pin, uint32_t  *_pVal): pin(_pin), pVal(_pVal) {}
    void setup() {
      pinMode(pin, INPUT);
      oldHall = digitalRead(pin);
    }
    void loop() {
      hall = digitalRead(pin);
      if (hall & !oldHall) {
        oldHall = 1;
        *pVal = micro - past;
        past = micro;
      }
      if (!hall & oldHall) {
        oldHall = 0;
      }
    }
};
//----Компоновка------------------------
uint32_t period = 0; //период
Cl_observer Observ(/*переменая*/&period,/*имя*/"period= ");
Cl_periodMeter Meter(/*датчик Холла*/2,/*время*/&period);
//-----main-----------------------
int main() {
  init();
  // setup
  Serial.begin(9600);
  Meter.setup();
  for (;;) {
    // loop
    mill = millis();
    micro = micros();
    Observ.loop();
    Meter.loop();
  }
  return 0;
}
/*Скетч использует 2272 байт (7%) памяти устройства. Всего доступно 32256 байт.
  Глобальные переменные используют 223 байт (10%) динамической памяти, оставляя 1825 байт для локальных переменных. Максимум: 2048 байт.
*/

Нет проблем с инжекторами они сами за программой не успевают.Напишите пример и сравним по скорости и весу.

4 холла на каждом по 1 инжектору задержка до впрыска и после.Чтото я сомниваюсь что он будет весить меньше.

Написать не проблема. Проблема в отсутствии схемы и диаграммы сигналов. Давайте, разрисуйте, напишу.

Зачем схемы диаграммы у нас готовая рабочая программа.Все компоненты жестко привязаны к своим фазам 90 градусов.Вам нужно добавить только временной интервал задержки впрыска и сам впрыск.Если боитесь что датчики убегут или форсунки то я сомниваюсь.Да и есле это произойдет то наврятли программа вернет датчик или форсунку Это уже искуственный разум нужно програмировать чтобы он при отсутствии сигнала с датчика давал сигнал с противоположного.И то это ясно как день.

А хорошая идея

[code]
/*
  ардуино пин 2 <--> датчик холла 1
  ардуино пин 3 <--> датчик холла 2
  ардуино пин 4 <--> датчик холла 3
  ардуино пин 5 <--> датчик холла 4
  ардуино пин 6 <--> инжектор 1
  ардуино пин 7 <--> инжектор 2
  ардуино пин 8 <--> инжектор 3
  ардуино пин 9 <--> инжектор 4
*/
//---------------------------------------------------
class Cl_HallToInject {
    const uint32_t time = 1000; // длительность 1 секунда
    const byte _Hall_pin  ; // пин холла
    const byte _Inject_pin;// пин инжектора
    bool Hall, Hall_old;
    bool Inject;
    uint32_t past = 0;
  public:
    Cl_HallToInject(byte Hall_pin, byte Inject_pin): _Hall_pin(Hall_pin), _Inject_pin(Inject_pin) {}
    void setup() {
      pinMode(_Hall_pin, INPUT);
      Hall_old = digitalRead( _Hall_pin);
      pinMode(_Inject_pin, OUTPUT);
      digitalWrite(_Inject_pin, Inject = 0);
    }
    void loop() {
      Hall = digitalRead( _Hall_pin);
      if (Hall && !Hall_old) { // если сработал датчик Холла
        Hall_old = 1;
        digitalWrite(_Inject_pin, Inject = 1); // то вкл Инжектор
        past = millis();
      }
      else if (!Hall && Hall_old) {
        Hall_old = 0;
      }
      if (Inject && millis() - past >= time) { // если истекло время
        digitalWrite(_Inject_pin, Inject = 0);  // то выкл Инжектор
      }
    }
};
//------------------Компоновка---------------------------------
Cl_HallToInject HallToInject1(/*датчик холла*/2,/*инжектор*/6);
Cl_HallToInject HallToInject2(/*датчик холла*/3,/*инжектор*/7);
Cl_HallToInject HallToInject3(/*датчик холла*/4,/*инжектор*/8);
Cl_HallToInject HallToInject4(/*датчик холла*/5,/*инжектор*/9);
//------------------main()---------------------------------
void setup() {
  HallToInject1.setup();
  HallToInject2.setup();
  HallToInject3.setup();
  HallToInject4.setup();
}

void loop() {
  HallToInject1.loop();
  HallToInject2.loop();
  HallToInject3.loop();
  HallToInject4.loop();
}
[/code]

Вот код использует 1868 байт (0) памяти.Глобальные переменные используют 61 байт (0) динамической памяти

uint32_t micro, mill; // переменные для micros() и millis()

//--------------------Cl_HallToInj-------------------------------
// класс Датчик Холла задает начало открытия инжектора
class Cl_HallToInj {
    uint32_t timeZ = 0; // длительность задержки впрыска
    uint32_t time = 0; // длительность впрыска
    uint32_t *const pTimeZ;// указатель на длительность задержки впрыска
    uint32_t *const pTime;// указатель на длительность задержки впрыска
    const byte hallPin  ; // пин холла
    const byte injPin;// пин инжектора
    bool hall, oldHall;
    bool statZ = 0; //состояние задержки
    bool inj;
    bool invH, invI; // инверсия выходов датчика Холла и инжектора
    uint32_t past = 0;
  public:
    Cl_HallToInj(byte _hallPin, bool _invH, byte _injPin, bool _invI, uint32_t *_pTimeZ, uint32_t *_pTime)
      :      hallPin(_hallPin), invH(_invH), injPin(_injPin), invI(_invI) , pTimeZ(_pTimeZ), 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;
        statZ = 1;
        timeZ = *pTimeZ; // выставить новое время задержки впрыска
        past = micro;
      }
      else if (!hall && oldHall) {
        oldHall = 0;
      }
      if (statZ && micro - past >= timeZ) {
        statZ = 0;
        inj = 1;            // то вкл Инжектор
        digitalWrite(injPin, invI ^ inj);
        time = *pTime; // выставить новое время впрыска
        past = micro;
      }
      if (inj && micro - past >= time) { // если истекло время
        inj = 0;                         // то выкл Инжектор
        digitalWrite(injPin, invI ^ inj);
      }
    }
};
//----Компоновка------------------------
uint32_t time = 1000; //время инжекции в микросекундах
uint32_t time1 = 1000; //время задержки инжекции в микросекундах

Cl_HallToInj HallToInject1(/*датчик Холла*/2,/*инверт сиг с датХолла*/1,/*инжектор*/6,/*инверт сиг на инжектор*/0,/*время задерж.впрыска*/&time1,/*время впрыска*/&time);
Cl_HallToInj HallToInject2(/*датчик Холла*/3,/*инверт сиг с датХолла*/1,/*инжектор*/7,/*инверт сиг на инжектор*/0,/*время задерж.впрыска*/&time1,/*время впрыска*/&time);
Cl_HallToInj HallToInject3(/*датчик Холла*/4,/*инверт сиг с датХолла*/1,/*инжектор*/8,/*инверт сиг на инжектор*/0,/*время задерж.впрыска*/&time1,/*время впрыска*/&time);
Cl_HallToInj HallToInject4(/*датчик Холла*/5,/*инверт сиг с датХолла*/1,/*инжектор*/9,/*инверт сиг на инжектор*/0,/*время задерж.впрыска*/&time1,/*время впрыска*/&time);
//-----main-----------------------
int main() {
  init();
  // setup

  HallToInject1.setup();
  HallToInject2.setup();
  HallToInject3.setup();
  HallToInject4.setup();
  for (;;) {
    // loop
    mill = millis();
    micro = micros();

    HallToInject1.loop();
    HallToInject2.loop();
    HallToInject3.loop();
    HallToInject4.loop();
  }
  return 0;
}
/*Скетч использует 2242 байт (0%) памяти устройства. Всего доступно 295253 байт.
  Глобальные переменные используют 121 байт (1%) динамической памяти, оставляя 8071 байт для локальных переменных. Максимум: 2048 байт.
*/

Извеняюсь тот скетч без задержек

Вообше автономный ремонт без участия человека хорошая идея.

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

В программе нет задержки включения инжектора. Какая величина этой задержки?
От оборотов зависит? А длительность открытия? У меня на хонде на ХХ форсунки открыты 4 мс. Дальше в зависимости от педальки открытие увеличивается с шагом 2 мс. Если бросить педаль и обороты больше 1000 закрыты совсем.
Какой даст результат выражение Inject && millis() - past >= time вы себе представляете ? Может быть должно быть так Inject && (millis() - past >= time) ?
Задержки на включение, зажигание нужны?
Не интересно делать одну функцию. Сравнивать надо полную программу.

/*
  порядок 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_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);
      }
    }
};
//------------------Компоновка---------------------------------
uint32_t time = 0; // длительность впрыска
Cl_XolostoiXod XolostoiXod(/*пин потенциометра*/A13,/*переменая*/&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);

//------------------main()---------------------------------
void setup() {
  XolostoiXod.setup();
  HallToInject1.setup();
  HallToInject2.setup();
  HallToInject3.setup();
  HallToInject4.setup();
}

void loop() {
  micro = micros();
  mill = millis();
  XolostoiXod.loop();
  HallToInject1.loop();
  HallToInject2.loop();
  HallToInject3.loop();
  HallToInject4.loop();

}

/*Скетч использует 2500 байт (0%) памяти устройства. Всего доступно 293952 байт.
  Глобальные переменные используют 96 байт (1%) динамической памяти, оставляя 8096 байт для локальных переменных. Максимум: 8192 байт.
*/

Вот код с авто.

Время не важно оно может и 159 на ХХ быть.У меня на ХХ с 1 микросикунды работает ниже форсы не открываются думаю работать будут. но заводится с 3-5.Время упровляется с помощью потенциометров.

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

Тахометр для опережения зажигания нужен и не более

Задержка на форсунки до впрыска не нужна она для опережения зажигания.

Предворительный пуск тоже не нужен каждая форсунка работает на свой цилиндр.

Для экономии может и пойдет а вот провал,детонация,и обедненая смесь обеспечены.

Сколько шагов?

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

Никогда не дожимал до упора. У меня логер на параметра движка на ноуте есть я его иногда подключаю лямбду проверить. Максимум что видел 40 мс. Он открывает не по педальке а по куче параметров. Лямбда туда тоже входит. Видно, когда не сильно нажал, вместе с лямбдой плавает открытие. На обороты кстати влияет на холостых. Чуть чуть плавают вместе с лямбдой.

Здесь injtime от 3 до 10ms.

Они с лямдой плавают потому что она перекрывает подачу если 4 мили это много для ХХ.

А 40 на ХХ это время такта.Чем быстрее движек крутится тем это время меньше.

40 было когда педаль в пол, 6500, 80км/ч на второй передаче. На ХХ 4 мс на холодном. На прогретом меньше. 2 мс шаг был на индикаторе программы. Судя по графику шаг меньше.

А какой обьем двигателя?

1500 114 сил атмосферник

8 свечей?

4

а откуда столько кобыл впрягли интересно.у меня тоже атмосферник по заводу 1351 79 лошедей 1400 с копейками расточил и хочу турбину или компрессор воткнуть после обкатки.

Сам удивляюсь. Вот этот http://race-wars.ru/harakteristiki-dvs/dvigateli-honda/136-d15z8.html

Втековский теперь понятно. А у меня опозитка как на субарике.

Можно с этого места поподробнее? У меня два вопроса:

1. Кто блещет?

2. Чем еще не блещет С?

пердлагаю повысить градус профанации и начать применять к С++ следующие эпитеты:

1.Асемблер.

2.Дальше он просто звезда осмиконечная.

Нет на него имбарго