Arduino.ru

Примите галаперидольчику, может поможет :)

ТС не знает, что такое ТЗ, за него пишут код, а он занимается размышлениями о пригодности января только для тазов и высокими высказываниями насчёт скорости языков...будущее ближе, чем казалось.

P.S. А я на январе уже стабильно завожусь) Москвич 412, всё инжекторное от 2121, Я5.1.2...

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

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

Я хотел бы внести некоторые пояснения для сообщества :)  ТС - типичный автокулибин. Я очень долго ошивался на одном крупном автопортале и таких повидал немало. Обычно это очень неглупые люди, хорошо разбирающиеся в технике и просто фонтанирующие разными идеями. Есть правда у них один недостаток - полная неспособность критически оценивать себя и свои проекты.

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

Их машины всегда выделяются из общего ряда. Они "правильно настроены", доработаны и модифицированы, в их конструкции  "исправлены ошибки производителей" - потому что мы же знаем, что мировые автобренды либо нифига не понимают в своем деле, либо подчинены жажде наживы, проискам мирового капитала, мировой закулисы или козням экологов (подставить по вкусу). У них матиз бегает 160 кмч, ауди-селедка жрет 8л по городу. Или небольшое изменение времени впрыска снижает расход в 100 раз.

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

я ноже "ногу задеру", раз уж "у этого столба" все отмечаются ;).

На средних оборатах 3000 об/мин длительность такта впуска меньше полоборота, то есть меньше 10 мс, впускной клапан открыт еще меньше времени, а форсунка должна рабоатать еще меньше, чем открыт впускной клапан, чтобы не лить на закрытый клапан.

На певых старницах это балагана ТС открывал форсунки на скока-скока? Гы!

Ну, вот теперь я начинаю понимать, как ТС смог в одном посте совместить такие утверждения:

Читать надо внимательней будет возникать меньше вопросов.

Здесь на форуме какието не внимательные товарищи всех как котят надо ткнуть носом чтоб негадили.

Здесь что написано? То что один скетч на 2 холла и 4 инжектора не работает,

/*
  ардуино пин 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() {
    
      *_pntIdling = map(analogRead(_pin), 0, 1023, 1, 80);//<--- здесь функция поворота ручки в значение холостого хода
    }
    void loop() {

      if (mill - past > 5) {
        *_pntIdling = map(analogRead(_pin), 0, 1023, 1, 80);//<--- здесь функция поворота ручки в значение холостого хода
      
            
      }
           
    }
};
//--------------------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() {
  
      *_pntTime = _pntTemp + map(analogRead(_pin), 0, 1023, 0, 80);//<--- здесь функция поворота ручки в значение температуры
    }
    void loop() {
     
      if (millis() - past > 5) {
        *_pntTime = _pntTemp + map(analogRead(_pin), 0, 1023, 0, 80);//<--- здесь функция поворота ручки в значение температуры
       }
  
    }
         
};/*
//--------------------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() {
     
      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); // то выключить инжектор
      }
    
    }
    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() {
   
      Hall = digitalRead(pin)^inv;
      if (Hall && !Hall_old ) {
        Hall_old = 1;
        Do();
      }
      if (!Hall && Hall_old ) {
        Hall_old = 0;
      }
    
    }
        
};
//----------Cl_Hall2_Inject4-----------------------------------------
// класс из 2-x датчиков Холла и 4-x инжекторов
class Cl_Hall2_Inject4 {
    Cl_Hall Hall_1, Hall_2;
    Cl_Inject Inject1, Inject2, Inject3, Inject4;
    byte num = 0; // номер инжектора для текущей инжекции
    byte stat = 0; // 0 отключен / 1 подготовка / 2 работа
  public:
    Cl_Hall2_Inject4(byte _pin1, byte _pin2, bool _invH, void (*_Do1)(), void (*_Do2)(),
                     byte _pin3, byte _pin4, byte _pin5, byte _pin6, bool _invI, uint32_t *_pnt_time1, uint32_t *_pnt_time2)
      : Hall_1(_pin1, _invH, _Do1), Hall_2(_pin2, _invH, _Do2),
        Inject1(_pin3, _invI, _pnt_time1, _pnt_time2), Inject2(_pin4, _invI, _pnt_time1, _pnt_time2),
        Inject3(_pin5, _invI, _pnt_time1, _pnt_time2), Inject4(_pin6, _invI, _pnt_time1, _pnt_time2) {}
    void setup() {
 
      Hall_1. setup();
      Hall_2. setup();
      Inject1. setup();
      Inject2. setup();
      Inject3. setup();
      Inject4. setup();
    }
    void loop() {
  
      if (stat == 0) return;
      Hall_1. loop();
      Hall_2. loop();
      Inject1. loop();
      Inject2. loop();
      Inject3. loop();
      Inject4. loop();
  
    }
    void inject() {
      if (stat == 0) return;
      if (stat == 1) {
        Inject1.inject();
        Inject2.inject();
        Inject3.inject();
        Inject4.inject();
      }
      if (stat == 2) {
        switch (num) {
          case 0:
            Inject1.inject();
            break;
          case 1:
            Inject2.inject();
            break;
          case 2:
            Inject3.inject();
            break;
          case 3:
            Inject4.inject();
            break;
        }
        ++num; if (num > 3)num = 0;
      }
    }
    void clear() {
      num = 0;
    }
    void preparation() {// включить подготовку
      stat = 1;
    }
    void work() {// включить работу
      stat = 2;
    }
       
};
//----------------Cl_Delay-------------------------------
// класс задержка запуск системы через некоторое время
class Cl_Delay {
    uint32_t time1, time2;
    void (*Do1)(), (*Do2)();
    byte stat = 0; // 0 - пауза / 1 - подготовка /2 - работа
    uint32_t past = 0;
  public:
    Cl_Delay(uint32_t _time1, void (*_Do1)(), uint32_t _time2, void (*_Do2)())
      : time1(_time1), Do1(_Do1), time2(_time2), Do2(_Do2) {}
    void loop() {
      if (stat == 0 && mill - past >= time1) {
        past = mill;
        stat = 1;
        (*Do1)();
      }
      if (stat == 1 && mill - past >= time2) {
        past = mill;
        stat = 2;
        (*Do2)();
      }
    }
};
//--------------компоновка----------------------------
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();
 
   
}

а второй скетч на 4 холла и 4 инжектора работает без нареканий.

[code]
/*
  порядок 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_Regulator Regulator3(/*пин*/A2,/*переменая*/&valC,/*min*/ 100,/*max*/300,/*имя*/"C=");
//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();
}
[/code]

Придется тоже тыкнуть носом.

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

А то что цикл на холостом 40 м это мое утверждение а тот кто со мной спорил у него цикл измеряется в сотнях как у производителей автопрома там такиеже работают усреднители и такимже пропихивают.

b707, насколько Вы оказались правы !!!!

А автопроизводители, действительно тупые!!!

(шмыгая разбитым от тыкания носом)

К сожалению и ауди и матиз и даже запорожец это все реальность.И дело не в кулибиничестве а в реализации своих желаний.Это называется ИЗОБРЕТАТЕЛЬНОСТЬ без которой мы сейчас за мамантами бегали и жили в пещерах.

Так накатим же за изобретательность!

А это верно замечено газ не может быть экономичнее как топливо, только финансово.

Не мне за руль у нас штраф 40000 + лишение.

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

Все это понимают. Кроме ТС.

Да, доганишь в балон.

О производстве и производителях. Только неосведомленный может утверждать что  с конвеера может выйти идеальный автомобиль.И его бесполезно ковырять всеравно через неделю он начнет чихать.Все что делается через конвеер требует доработки.А сколько сходит брака одному богу известно.Не нужно быть наивным и верить что новый и еще не притерлось а о допустимых потеков по госту или о простом без присадок малсе залитом в двигатель типа на обкатку это полная чуш.В авто нечему претиратся кроме колец.

Мда.

Часть изобретателей - сумасшедшие. Некоторые - гении. Причем это одни и те же люди :)

Производители - они, само собой, тупые.

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

Стояла она открытая, т.к. охлаждения не хватало. И надо же, блин, какой-то раздолбай, проводя работы под крышей цеха, уронил в неё молоток. Сломалась.

Ну, чего делать? Случай явно негарантийный. заказывать ремонт за бабки ... кто жил в СССР поймёт, что это называлось "за валюту" - хрена-се ... турма сидэть! Собрались все заводские кулибины и давай кумекать.

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

Оформили это как рацпредложение передовика произврдства слесаря такого-то и успокоились. 

Но на беду, информация дошла до высокого начальства в минсельхозе. Там нахмурили брови и давай орать: это блин что ж такое! Усовершенствовали машину, что она стала работать на 20% быстрее и без отходов и молчите? Вы что тут частную лавочку с конкуренцией устраивате? Срочно провести совещание с участием всех эксплуатантов этой машины с других заводов, всё им рассказть, показать, а тем обязательно внедрить рацпредложение у себя и отчитаться.

Вот так наш передовой слесарь тупых япошек уделал :)

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

qwone мне надо чтобы 3 потенциометра одновременно в одной переменной time работали а они опять сами по себе

/**/
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 байт.
*/

Вот вам этот код 

/**/
unsigned long mill;
//-----Cl_Regulator-----------------------
// класс регулятор - меняет значение переменной
//в заданых пределах ручкой потенциометра каждые 0.2 сек
class Cl_Regulator {
  protected:
    int  *const pVal;
    const byte pin_1, pin_2, pin_3;
    const int  minVal_1, minVal_2, minVal_3;
    const int  maxVal_1, maxVal_2, maxVal_3;
    char * name_1, * name_2, * name_3;
    unsigned long past = 0;
  public:
    Cl_Regulator(int  *_pVal,
                 byte _pin_1,  int  _minVal_1, int  _maxVal_1, char *_name_1,
                 byte _pin_2,  int  _minVal_2, int  _maxVal_2, char *_name_2,
                 byte _pin_3,  int  _minVal_3, int  _maxVal_3, char *_name_3)
      :         pVal(_pVal),
                pin_1(_pin_1),  minVal_1(_minVal_1), maxVal_1(_maxVal_1), name_1(_name_1),
                pin_2(_pin_2),  minVal_2(_minVal_2), maxVal_2(_maxVal_2), name_2(_name_2),
                pin_3(_pin_3),  minVal_3(_minVal_3), maxVal_3(_maxVal_3), name_3(_name_3)   {}
    void setup() {}
    void loop() {
      if (mill - past >= 200) {
        past = mill;
        int Val_1 = map(analogRead(pin_1), 0, 1023, minVal_1, maxVal_1);
        int Val_2 = map(analogRead(pin_2), 0, 1023, minVal_2, maxVal_2);
        int Val_3 = map(analogRead(pin_3), 0, 1023, minVal_3, maxVal_3);
        *pVal = Val_1 + Val_2 + Val_3;
        Serial.print(*pVal);
        Serial.print("  ");
        Serial.print(name_1);
        Serial.print(Val_1);
        Serial.print("  ");
        Serial.print(name_2);
        Serial.print(Val_2);
        Serial.print("  ");
        Serial.print(name_3);
        Serial.print(Val_3);
        Serial.println();
      }
    }
};
//----Компоновка------------------------
int val = 100; //регулируемая переменая
Cl_Regulator Regulator1(/*переменая*/&val,
    /*пин*/A0,/*min*/100,/*max*/300,/*имя*/"A=",
    /*пин*/A1,/*min*/ -300,/*max*/ -100,/*имя*/"B=",
    /*пин*/A2,/*min*/ -300,/*max*/300,/*имя*/"C=");
//-----main-----------------------
int main() {
  init();
  // setup
  Serial.begin(9600);
  for (;;) {
    // loop
    mill = millis();
    Regulator1.loop();
  }
  return 0;
}
/*Скетч использует 2508 байт (7%) памяти устройства. Всего доступно 32256 байт.
  Глобальные переменные используют 231 байт (11%) динамической памяти, оставляя 1817 байт для локальных переменных. Максимум: 2048 байт.
*/

/**/
unsigned long mill;
//-----Cl_Regulator-----------------------
// класс регулятор - меняет значение переменной
//в заданых пределах ручкой потенциометра каждые 0.2 сек
class Cl_Regulator {
  protected:
    int  *const pVal;
    const byte pin_1, pin_2, pin_3;
    const int  minVal_1, minVal_2, minVal_3;
    const int  maxVal_1, maxVal_2, maxVal_3;
    char * name_1, * name_2, * name_3;
    unsigned long past = 0;
  public:
    Cl_Regulator(int  *_pVal,
                 byte _pin_1,  int  _minVal_1, int  _maxVal_1, char *_name_1,
                 byte _pin_2,  int  _minVal_2, int  _maxVal_2, char *_name_2,
                 byte _pin_3,  int  _minVal_3, int  _maxVal_3, char *_name_3)
      :         pVal(_pVal),
                pin_1(_pin_1),  minVal_1(_minVal_1), maxVal_1(_maxVal_1), name_1(_name_1),
                pin_2(_pin_2),  minVal_2(_minVal_2), maxVal_2(_maxVal_2), name_2(_name_2),
                pin_3(_pin_3),  minVal_3(_minVal_3), maxVal_3(_maxVal_3), name_3(_name_3)   {}
    void setup() {}
    void loop() {
      if (mill - past >= 200) {
        past = mill;
        int Val_1 = map(analogRead(pin_1), 0, 1023, minVal_1, maxVal_1);
        int Val_2 = map(analogRead(pin_2), 0, 1023, minVal_2, maxVal_2);
        int Val_3 = map(analogRead(pin_3), 0, 1023, minVal_3, maxVal_3);
        *pVal = Val_1 + Val_2 + Val_3;
        Serial.print(*pVal);
        Serial.print("  ");
        Serial.print(name_1);
        Serial.print(Val_1);
        Serial.print("  ");
        Serial.print(name_2);
        Serial.print(Val_2);
        Serial.print("  ");
        Serial.print(name_3);
        Serial.print(Val_3);
        Serial.println();
      }
    }
};
//----Компоновка------------------------
int val = 100; //регулируемая переменая
Cl_Regulator Regulator1(/*переменая*/&val,
    /*пин*/A0,/*min*/100,/*max*/300,/*имя*/"A=",
    /*пин*/A1,/*min*/ -300,/*max*/ -100,/*имя*/"B=",
    /*пин*/A2,/*min*/ -300,/*max*/300,/*имя*/"C=");
//-----main-----------------------
int main() {
  init();
  // setup
  Serial.begin(9600);
  for (;;) {
    // loop
    mill = millis();
    Regulator1.loop();
  }
  return 0;
}
/*Скетч использует 2508 байт (7%) памяти устройства. Всего доступно 32256 байт.
  Глобальные переменные используют 231 байт (11%) динамической памяти, оставляя 1817 байт для локальных переменных. Максимум: 2048 байт.
*/

Спасибо. А что считает период метр?У меня проверять сейчас неначем датчики в трамблер уже впоял проводку теперь под них опять переделывать надо. 

Цитата " А что считает период метр?У меня проверять сейчас неначем датчики в трамблер уже впоял проводку теперь под них опять переделывать надо. " Какой метр- покажите это в какой программе?

/**/
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;
}

Считайте что это у вас тахометр.Точнее периодомер. Меряет время оборота .

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

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

qwone еще вопрос к вам такой, если я вместо функции map 

 int Val_1 = map(analogRead(pin_1), 0, 1023, minVal_1, maxVal_1);

подставлю функцию constrain

int Val_1 = constrain(analogRead(pin_1), 5, 10, minVal_1, maxVal_1);

то потенциометр будет работать от 0 до 1023 но программе, тоесть в переменную передаст только от 5 до 10 ,а если потенциометр крутить дальше то будет всегда 10 или в другую сторону 5, я правельно мыслю? 

qwone еще вопрос к вам такой, если я вместо функции map

 int Val_1 = map(analogRead(pin_1), 0, 1023, minVal_1, maxVal_1);

подставлю функцию constrain

int Val_1 = constrain(analogRead(pin_1), 5, 10, minVal_1, maxVal_1);

то потенциометр будет работать от 0 до 1023 но программе, тоесть в переменную передаст только от 5 до 10 ,а если потенциометр крутить дальше то будет всегда 10 или в другую сторону 5, я правельно мыслю?

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

Паровозы мы не строим.У меня стояли форсы которые лили на закрытый клапан и не че машина работала.Здесь не надо глубоких знаний ,и 3 классов хватит чтобы понять что при закрытом клапане бензину деватся некуда кроме как на сам клапон или на стенки оседать и от температуры испорятся.И не какие цыклы здесь не причем.У МЕНЯ ВСЕ ДЕЛАЕТ МЕХАННИКА Я УСТАЛ ПОВТОРЯТЬ.ПОСЛЕ ХОЛОСТОВА ХОДА К -ДЖЕТРОНИК РАБОТАЕТ В СВОЕМ ОБЫЧНОМ РЕЖИМЕ.

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

Да именно. 

а зачем тогда они электрические?

http://arduino.ru/Reference/Constrain

Попробуйте Я этим не пользуюсь. Все равно в сериал отображается . Так что формулу и поворот потенциомера подбирите по месту и ситуации.

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

дак чтобы помочь тебе, нужно понять что ты там накуролесил. Я понял дело было так. Изначально альфа была с электронным впрыском, т.е. форсы были электрические и количество топлива регулировалось временем открытия форсунок.  Потом сгорел ЭБУ.

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

У меня 3 комплекта форсунок 2 от альфы 15и17 ом, 1 от хендей 15 ом более производительные ставил на делей хендей на 5 процентов больше льют.  На выбор бери нехочу.Сейчас стоят Хендей через переходник.

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

Сразу видно человек не вкурсе тему не читал.Нет они крякнут от постоянки.Причем очень быстро непройдет и 10 минут.

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

Скажу как человек довольно не плохо разбирающийся в двигателях. На самом деле не нужно идеально чёткой привязки времени открытия форсунки к градусу положения коленвала, и ходу поршня. +/- 10% на 1000 оборотах даже не заметно практически. А оборотах больше 3000, уже вполне можно открывать все четыре форсунки чуть ли не за один такт одновременно. Важно лишь время её открытия, что-бы создавалась нужная концентрация смеси. Моё мнение, такое, что чем выше обороты тем можно больше пренебрегать точностью времени открытия. А вот длительностью открытия пренебрегать не стоит.

В обычном ЭБУ давление одно на всех оборотах около 3 бар.

У меня давленим можно управлять и временем.То есть к -джетроник подготавливает смесь а я всеголишь определяю время в которое ее подать здесь не надо лишних датчиков.

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

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

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

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

Минус ручной регулировки и плюс ЭБУ регулировки.

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

С ЭБУ я могу  регулировать смесь в любом диапозоне не влияя на весь.

Время от оборотов не может зависить Именно время упавляет оборотами.А вот открытие форсунок ограничевается оборотами.Что вы все заладили обороты тахометр?Вы движек оборотами .......даже слов нет.

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

Чтобы управлять с помощью оборота нужно его достичь.По этому в сети нет примеров или удачных проэктов.