Arduino.ru

ну пробуйте дело ваше может получится

А!!! Класс! Квоны распростроняются!!! Галлактика в опасности!

uint8_t in_state = PIND;              // фиксируем состояние  входов
  uint8_t currBit = 4;                  // бит вх. порта 2 ардуино, 

Эти две строчки я так понял переменные?currBit это пин холла? а in_state пин форсунки?

Как я когда то начинал ничего не понимал вот вам подробная описание скетча:

На форуме у ребят много к чему научился лучьше спрашивайте узнавайте чем спорит с ними желаю успехов

  uint8_t currBit = 4;                  // бит вх. порта 2 ардуино, 

Вы тут уже столько времени трётесь, тему вон на 500 постов запостили, так почитайте же хоть что-нибудь, не всё ж писать. Это переменная для сохранения ВСЕХ восьми пинов регистра D.

  uint8_t currBit = 4;                  // бит вх. порта 2 ардуино, 

Уже прочел. Я откуда знаю что такое PIND и с чем его едят ,поэтому и спросил.

Так надо знать! А если встретилось, то сначала прочесть, а только если не поможет - спроашивать.

Я с ними не спорю.Это они спорят.

A я чё? Я ниче. Другие вон чё, и ничё, а я чуть чё, и сразу вон чё!

 .

Я такое первый раз встретил.Может это переменная такая которую обьявить забыли.

qwone нужна помощь Проблемма в том что если я увеличиваю время допустим до 50 милисекунд получается следующее.

1 датчик дал сигнал зажигается светодиод ,если светодиод не погас и 2 датчик дал сигнал ,то 1 светодиод продолжает гореть ,то же происходит и с 3 и с 4 и опять 1-2-3-4-1-2-3-4 так до бесконечности до того момента пока не перестанут довать сигнал датчики.После этого проходит некоторое(скорее всего программа складывает время) время и все светодиоды тухнут.

Выложете или укажите пожалуста эту программу.

/*
  порядок 1-3-2-4
  под мега 2560
  ардуино пин A12 <--> на вывод термистора2 // cчитаем еще один потенциометр
  ардуино пин A13 <--> на вывод термистора1 // cчитаем еще один потенциометр  
  ардуино пин A14 <--> средний вывод потенциометра нагрузки
  ардуино пин A15 <--> средний вывод потенциометра холостой ход
  расчет потенциометров-холостой ход без нагрузки без прогревa
                        холостой ход + нагрузка + прогрев 
                        холостой ход + прогрев без нагрузки
                        холостой ход + нагрузка без прогревa
  ардуино пин 8 <--> датчик холла 1
  ардуино пин 9 <--> датчик холла 3
  ардуино пин 10 <--> датчик холла 2
  ардуино пин 11 <--> датчик холла 4
  ардуино пин 22 <--> инжектор 2
  ардуино пин 23 <--> инжектор 4
  ардуино пин 24 <--> инжектор 1
  ардуино пин 25 <--> инжектор 3
  ардуино пин 46 <--> катушка 1
  ардуино пин 38 <--> катушка 2
*/
uint32_t micro, mill; // переменные для micros() и millis()


//--------------------Cl_Operejenie---------------------------------------------
// класс холостого хода
class Cl_Operejenie {
    const byte _pin;   
    uint32_t *const _pntOperejenie;// указатель переменную которая меняет значение холостого хода по положению ручки потенциометра
    uint32_t past = 0;
  public:    Cl_Operejenie(byte pin, uint32_t *pntOperejenie)
    : _pin(pin), _pntOperejenie(pntOperejenie) {}
    void setup() {
      *_pntOperejenie = map(analogRead(_pin), 0, 1023, 0, 10000);//<--- здесь функция поворота ручки в значение холостого хода
    }
    void loop() {
      if (micro - past > 1) {
        *_pntOperejenie = map(analogRead(_pin), 0, 1023, 0, 10000);//<--- здесь функция поворота ручки в значение холостого хода
      }
    }
};
//--------------------Cl_HallCamutator-------------------------------
// класс Датчик Холла задает начало открытия инжектора
class Cl_HallCamutator {
    uint32_t timeC = 0; // длительность задержки впрыска
    uint32_t time = 0; // длительность впрыска
    uint32_t *const pTimeC;// указатель на длительность задержки впрыска
    uint32_t *const pTime;// указатель на длительность задержки впрыска
    const byte hallPin  ; // пин холла
    const byte CamutatorPin;// пин инжектора
    bool hall, oldHall;
    bool statC = 0; //состояние задержки
    bool Camutator;
    bool invH, invC; // инверсия выходов датчика Холла и инжектора
    uint32_t past = 0;
  public:
    Cl_HallCamutator(byte _hallPin, bool _invH, byte _CamutatorPin, bool _invC, uint32_t *_pTimeC, uint32_t *_pTime)
      :      hallPin(_hallPin), invH(_invH), CamutatorPin(_CamutatorPin), invC(_invC) , pTimeC(_pTimeC), pTime(_pTime) {}
    void setup() {
      pinMode(hallPin, INPUT);
      oldHall = digitalRead(hallPin)^invH;
      pinMode(CamutatorPin, OUTPUT);
      Camutator = 0;
      digitalWrite(CamutatorPin, Camutator ^ invC);
    }
    void loop() {
      hall = digitalRead(hallPin)^invH;
      if (hall && !oldHall) { // если сработал датчик Холла
        oldHall = 1;
        statC = 1;
        timeC = *pTimeC; // выставить новое время задержки впрыска
        past = micro;
      }
      else if (!hall && oldHall) {
        oldHall = 0;
      }
      if (statC && micro - past >= timeC) {
        statC = 0;
        Camutator = 1;            // то вкл Инжектор
        digitalWrite(CamutatorPin, invC ^ Camutator);
        time = *pTime; // выставить новое время впрыска
        past = micro;
      }
      if (Camutator && micro - past >= time) { // если истекло время
        Camutator = 0;                         // то выкл Инжектор
        digitalWrite(CamutatorPin, invC ^ Camutator);
      }
    }
};
//----Компоновка------------------------


uint32_t timeC = 0; //время задержки комутации в микросекундах
Cl_Operejenie Operejenie(/*пин потенциометра*/A13,/*переменая*/&timeC);
    
uint32_t time = 2; //время комутации в микросекундах  
Cl_HallCamutator HallCamutator1(/*датчик Холла1*/8,/*инверт сиг с датХолла1*/1,/*катушка1*/46,/*инверт сиг на камутатор1*/0,/*время задерж.камутации*/&timeC,/*время камутации*/&time);
Cl_HallCamutator HallCamutator2(/*датчик Холла3*/9,/*инверт сиг с датХолла3*/1,/*катушка1*/46,/*инверт сиг на камутатор1*/0,/*время задерж.камутации*/&timeC,/*время камутации*/&time);
Cl_HallCamutator HallCamutator3(/*датчик Холла2*/10,/*инверт сиг с датХолла2*/1,/*катушка2*/38,/*инверт сиг на камутатор2*/0,/*время задерж.камутации*/&timeC,/*время камутации*/&time);
Cl_HallCamutator HallCamutator4(/*датчик Холла4*/11,/*инверт сиг с датХолла4*/1,/*катушка2*/38,/*инверт сиг на камутатор2*/0,/*время задерж.камутации*/&timeC,/*время камутации*/&time);

//-----main-----------------------
int main() {
  init();
  // setup
  Serial.begin(9600);
  
  Operejenie.setup();  
  HallCamutator1.setup();
  HallCamutator2.setup();
  HallCamutator3.setup();
  HallCamutator4.setup(); 

  for (;;) {
    // loop
    Serial.print(" Operejenie ");
   Serial.print(timeC);
    mill = millis();
    micro = micros();
    Observ.loop();
    Meter.loop();    
    RegulatorInject.loop();
    Operejenie.loop();    
    HallCamutator1.loop();
    HallCamutator2.loop();
    HallCamutator3.loop();
    HallCamutator4.loop();    
   
  }
  return 0;
}

А вы в курсе, что отработать меньше 2 микросекунд (2/100 000 сек) не реально. Программа работает с точностью (1/10000 сек) 

Да.Там миллис пробовал пропустил неисправил.

Ну только так 

/*
  порядок 1-3-2-4
  под мега 2560
  ардуино пин A12 <--> на вывод термистора2 // cчитаем еще один потенциометр
  ардуино пин A13 <--> на вывод термистора1 // cчитаем еще один потенциометр
  ардуино пин A14 <--> средний вывод потенциометра нагрузки
  ардуино пин A15 <--> средний вывод потенциометра холостой ход
  расчет потенциометров-холостой ход без нагрузки без прогревa
                        холостой ход + нагрузка + прогрев
                        холостой ход + прогрев без нагрузки
                        холостой ход + нагрузка без прогревa
  ардуино пин 8 <--> датчик холла 1
  ардуино пин 9 <--> датчик холла 3
  ардуино пин 10 <--> датчик холла 2
  ардуино пин 11 <--> датчик холла 4
  ардуино пин 22 <--> инжектор 2
  ардуино пин 23 <--> инжектор 4
  ардуино пин 24 <--> инжектор 1
  ардуино пин 25 <--> инжектор 3
  ардуино пин 46 <--> катушка 1
  ардуино пин 38 <--> катушка 2
*/
uint32_t mill; // переменные для millis()
//--------------------Cl_Operejenie---------------------------------------------
// класс холостого хода
class Cl_Operejenie {
    const byte pin;
    uint32_t *const data;
    uint32_t past = 0;
  public:    Cl_Operejenie(byte pin_, uint32_t *data_): pin(pin_), data(data_) {}
    void setup() {
      *data = map(analogRead(pin), 0, 1023, 0, 100);
    }
    void loop() {
      if (mill - past > 200) {
        *data = map(analogRead(pin), 0, 1023, 0, 100);
      }
    }
};
//--------------------Cl_HallCamutator-------------------------------
// класс Датчик Холла задает начало открытия инжектора
class Cl_HallCamutator {
    uint32_t timeC = 0; // длительность задержки впрыска
    uint32_t time = 0; // длительность впрыска
    uint32_t *const pTimeC;// указатель на длительность задержки впрыска
    uint32_t *const pTime;// указатель на длительность задержки впрыска
    const byte hallPin  ; // пин холла
    const byte CamutatorPin;// пин инжектора
    bool hall, oldHall;
    bool statC = 0; //состояние задержки
    bool Camutator;
    bool invH, invC; // инверсия выходов датчика Холла и инжектора
    uint32_t past = 0;
  public:
    Cl_HallCamutator(byte hallPin_, bool invH_, byte CamutatorPin_, bool invC_, uint32_t *pTimeC_, uint32_t *pTime_)
      :      hallPin(hallPin_), invH(invH_), CamutatorPin(CamutatorPin_), invC(invC_) , pTimeC(pTimeC_), pTime(pTime_) {}
    void setup() {
      pinMode(hallPin, INPUT);
      oldHall = digitalRead(hallPin)^invH;
      pinMode(CamutatorPin, OUTPUT);
      Camutator = 0;
      digitalWrite(CamutatorPin, Camutator ^ invC);
    }
    void loop() {
      hall = digitalRead(hallPin)^invH;
      if (hall && !oldHall) { // если сработал датчик Холла
        oldHall = 1;
        statC = 1;
        timeC = *pTimeC; // выставить новое время задержки впрыска
        past = mill;
      }
      else if (!hall && oldHall) {
        oldHall = 0;
      }
      if (statC && mill - past >= timeC) {
        statC = 0;
        Camutator = 1;            // то вкл Инжектор
        digitalWrite(CamutatorPin, invC ^ Camutator);
        time = *pTime; // выставить новое время впрыска
        past = mill;
      }
      if (Camutator && mill - past >= time) { // если истекло время
        Camutator = 0;                         // то выкл Инжектор
        digitalWrite(CamutatorPin, invC ^ Camutator);
      }
    }
};
//----Компоновка------------------------
uint32_t timeC = 0; //время задержки комутации в микросекундах
Cl_Operejenie Operejenie(/*пин потенциометра*/A13,/*переменая*/&timeC);
uint32_t time = 2; //время комутации в милисекундах
Cl_HallCamutator HallCamutator1(/*датчик Холла1*/8,/*инверт сиг с датХолла1*/1,/*катушка1*/46,/*инверт сиг на камутатор1*/0,/*время задерж.камутации*/&timeC,/*время камутации*/&time);
Cl_HallCamutator HallCamutator2(/*датчик Холла3*/9,/*инверт сиг с датХолла3*/1,/*катушка1*/46,/*инверт сиг на камутатор1*/0,/*время задерж.камутации*/&timeC,/*время камутации*/&time);
Cl_HallCamutator HallCamutator3(/*датчик Холла2*/10,/*инверт сиг с датХолла2*/1,/*катушка2*/38,/*инверт сиг на камутатор2*/0,/*время задерж.камутации*/&timeC,/*время камутации*/&time);
Cl_HallCamutator HallCamutator4(/*датчик Холла4*/11,/*инверт сиг с датХолла4*/1,/*катушка2*/38,/*инверт сиг на камутатор2*/0,/*время задерж.камутации*/&timeC,/*время камутации*/&time);
//-----main-----------------------
int main() {
  init();
  // setup
  Operejenie.setup();
  HallCamutator1.setup();
  HallCamutator2.setup();
  HallCamutator3.setup();
  HallCamutator4.setup();

  for (;;) {
    // loop
    mill = millis();
    Operejenie.loop();
    HallCamutator1.loop();
    HallCamutator2.loop();
    HallCamutator3.loop();
    HallCamutator4.loop();
  }
  return 0;
}
/*Скетч использует 2520 байт (0%) памяти устройства. Всего доступно 253952 байт.
  Глобальные переменные используют 124 байт (1%) динамической памяти, оставляя 8068 байт для локальных переменных. Максимум: 8192 байт.
*/

Еще вопрос такой правильно ли я делаю график опенежения или нужно по другому.

/*в переменной set0 значение 
1  6000
2  800
3  5000 
4  5134 
5  4883
6  4829
7  4938
8  4889
9  4843
10 4808
11 4778
12 4747
13 4725
14 4717
15 4770
16 4833
17 4912
18 4938
19 4985
20 5098
21 5132
22 5167
23 5198
24 5206
25 5253
26 5278
/**//**/

  
 
    
if (time0 == set0 && period <= 625000){
   time0 = set1;
   if (period > 625000)
      time0 = set0;
  }
    
  /* 
если значение в переменной таймO равно 6000 и период равен или меньше 625000 
то присваеваем значение set0 значению таймO
иначе эсли период больше 625000
то присваеваем значение set0 значению таймO
 */

Таких строк 26 26 параметров относительно оборотов двигателя.

infyniti, а на вашем инновационном нанодвигателе цилиндры в каком порядке работають?

Думаю, что в любом, причём на лету адаптируются в зависимости от состава смеси, IQ водителя и фазы Луны.

1-3-2-4

а у добрых людей 1-3-4-2

А у некоторых добрых людей 1-2-4-3 наврятли я ошибся у меня опозитка не рядный.Если только с углом.Я специально поставил потенциометр для корекции.

При такой схеме

У меня 2 варианта 1-3-4-2 и 1-2-4-3 Точно... куда смотрел провода когда снимал?

А может и такая 

Завтра посмотрю

может так? Порядок работы двигателя: 1 – 4 – 3 – 2 или 1 – 2 – 3 – 4.

Нет я сейчас на второй каленвал смотрел.Я когда правода снимал с крышки на катушки по порядку ставил.1-3-2-4 или 1-4-2-3.

Но у меня 2 катушки правая и левая без разницы 2 раза правая 2 раза левая бьют.

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

qwone а что если

 AnalogRead() — скорость выполнения 110 мкс.

AnalogWrite() — 2000 мкс

SerialPrintLn() — при скорости 9600 около 250мкс, а при максимальной скорости около 3мкс.

DigitalWrite() — 1800мкс

DigitalRead() — 1900мкс

все это дело ригистрами прописать? 

https://geektimes.ru/post/255744/

"У моего соседа была замечательная кобылка Соня, сивая такая, грациозная красотка. Так вот как-то захворала она и начала бредить ..."

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

А если не поймёт за что, покажите ему вот такой тест:

template <typename T> inline Print & operator << (Print &s, T n) { s.print(n); return s; }

#define TEST(x) \
	{	 \
	const unsigned long startPoint = millis(); \
	for (int i = 0; i < 1000; i++) { \
		x; x; x; x; x; x; x; x; x; x; \
	} \
	const unsigned long endPoint = millis(); \
	const unsigned long diff = endPoint - startPoint; \
	Serial << "10000 of " << #x << ": " << diff << "ms"; \
	Serial << " ::: Single " << #x << ": " << ((double)diff / 10000.0) << "ms\n"; \
	}


void setup() {
	pinMode(10, OUTPUT);
	pinMode(11, INPUT);
	Serial.begin(115200);
	
	TEST(digitalWrite(10, HIGH));
	TEST(digitalRead(11));
	TEST(analogRead(0));
	TEST(analogWrite(3, 127));
}

void loop() {
}

Пусть он его запустит и убедится что

Все, кроме analogRead выполняется за 10мкс и меньше, а analogRead - за 110мкс, здесь он не ошибся.

Если бы у него (или у Вас) были мозги, он (или Вы) сразу бы заметил, что в его данных ошибка, т.к. не может такая сложная операция, как analogRead выполняться в 15 раз медленнее, чем digitalWrite.

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

Как можно проверить скорость моего кода?

1. Выберите свободный пин (FPIN)
2. Сконфигурируйте его на OUTPUT
3. Объявите глобальную переменную bool kaka = false;
4. В ключевых точках программы вставьте вызов: digitalWrite(FPIN, kaka = !kaka);
5. Подключите к FPIN осциллограф и следите.

При каждом взове команды из п.4, состояние пина будет меняться с LOW на HIGH или наоборот (при нечётном вызове - LOW->HIGN, при чётном - HIGH->LOW).

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

А без осциллографа ни как?

На глаз, либо ещё одной ардуиной с таймером в режиме захвата.

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

Вроде нашел причину.

Если датчик дает сигнал и время не вышло то при следующем сигнале выстовляется новое время.

Помоготе исправить проблемму.

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

Я Вам уже много раз говорил, что либо идите в "Ищу исполнителя", либо учитесь программировать. Вы же предпочитаете не делать ни того, ни другого, а клянчить о помощи по каждой мелкой ерунде. Квон, конечно, известный альтруист, но что Вы будете делать, когда и ему надоест? Может таки поучиться чему-нибудь и хоть таку мелочь уметь делать самому?

В том-то и беда, если подскажу, то сами уже никогда не исправите.

Так что давайте, думайте, изучайте, ... ну, или ждите Квона.

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

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

4дня рылся с ускорением а решилось одним ответом.Оно нафик не нужно.

Не совсем я и тупой больше половины я понимаю.

    bool hall, oldHall;

Вот это я не понимаю

    uint32_t past = 0;

Это что переменная времени?

И пока все.Остальное закаментировано и читается.

Может и не верно но это как я читаю

//--------------------Cl_HallToInj-------------------------------
// класс Датчик Холла задает начало открытия инжектора
class Cl_HallToInj {
    uint32_t timeI = 0; // длительность задержки впрыска
    uint32_t time1 = 0; // длительность впрыска
    uint32_t *const pTimeI;// указатель на длительность задержки впрыска
    uint32_t *const pTime1;// указатель на длительность задержки впрыска
    const byte hallPin  ; // пин холла
    const byte injPin;// пин инжектора
    bool hall, oldHall;//переменные для холла но почему 2 а не1
    bool statI = 0; //состояние задержки
    bool inj;//для инжектора
    bool invH, invI; // инверсия выходов датчика Холла и инжектора
    uint32_t past = 0;//походу для таймера
  public:
    Cl_HallToInj(byte _hallPin, bool _invH, byte _injPin, bool _invI, uint32_t *_pTimeI, uint32_t *_pTime1)
      :      hallPin(_hallPin), invH(_invH), injPin(_injPin), invI(_invI) , pTimeI(_pTimeI), pTime1(_pTime1) {}
    void setup() {
      pinMode(hallPin, INPUT);                     //вход
      oldHall = digitalRead(hallPin)^invH;         //присваеваем состояние
      pinMode(injPin, OUTPUT);                     //выход
      inj = 0;                                     //присваеваем 0
      digitalWrite(injPin, inj ^ invI);            //устанавливаем инверсию
    }
    void loop() {
      hall = digitalRead(hallPin)^invH;            //смотрим состояние
      if (hall && !oldHall) {                      //если сработал датчик Холла
        oldHall = 1;                               //присваеваем 1
        statI = 1;                                 //присваеваем 1
        timeI = *pTimeI;                           //выставить новое время задержки впрыска
        past = micro;                              //присваеваем время ?
      }
      else if (!hall && oldHall) {                 //иначе если 0и1 то
        oldHall = 0;                               //присваеваем 0
      }
      if (statI && micro - past >= timeI) {        //если истекло время
        statI = 0;                                 //присвоить 0
        inj = 1;                                   //то вкл Инжектор
        digitalWrite(injPin, invI ^ inj);          //устанавливаем инверсию
        time1 = *pTime1;                           //выставить новое время впрыска
        past = micro;                              //присваеваем время ?
      }
      if (inj && micro - past >= time1) {          //если истекло время
        inj = 0;                                   //то выкл Инжектор
        digitalWrite(injPin, invI ^ inj);          //устанавливаем инверсию
      }
    }
}

У меня 2 версии почему так происходит.

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

2То что нужно перепесать строки 

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

//--------------------Cl_HallToInj-------------------------------
// класс Датчик Холла задает начало открытия инжектора
class Cl_HallToInj {
    uint32_t timeI = 0; // длительность задержки впрыска
    uint32_t time1 = 0; // длительность впрыска
    uint32_t *const pTimeI;// указатель на длительность задержки впрыска
    uint32_t *const pTime1;// указатель на длительность задержки впрыска
    const byte hallPin  ; // пин холла
    const byte injPin;// пин инжектора
    bool hall, oldHall;//переменные для холла но почему 2 а не1
    bool statI = 0; //состояние задержки
    bool inj;//для инжектора
    bool invH, invI; // инверсия выходов датчика Холла и инжектора
    uint32_t past = 0;//походу для таймера
  public:
    Cl_HallToInj(byte _hallPin, bool _invH, byte _injPin, bool _invI, uint32_t *_pTimeI, uint32_t *_pTime1)
      :      hallPin(_hallPin), invH(_invH), injPin(_injPin), invI(_invI) , pTimeI(_pTimeI), pTime1(_pTime1) {}
    void setup() {
      pinMode(hallPin, INPUT);                     //вход
      oldHall = digitalRead(hallPin)^invH;         //присваеваем состояние
      pinMode(injPin, OUTPUT);                     //выход
      inj = 0;                                     //присваеваем 0
      digitalWrite(injPin, inj ^ invI);            //устанавливаем инверсию
    }
    void loop() {
      hall = digitalRead(hallPin)^invH;            //смотрим состояние
      if (hall && !oldHall) {                      //если сработал датчик Холла
        oldHall = 1;                               //присваеваем 1
        statI = 1;                                 //присваеваем 1
        timeI = *pTimeI;                           //выставить новое время задержки впрыска
        past = micro;                              //присваеваем время ?
        //** вот сюда надо поставить это
        inj = 0;                                   //то выкл Инжектор
        digitalWrite(injPin, invI ^ inj);          //устанавливаем инверсию
      }
      else if (!hall && oldHall) {                 //иначе если 0и1 то
        oldHall = 0;                               //присваеваем 0
      }
      if (statI && micro - past >= timeI) {        //если истекло время
        statI = 0;                                 //присвоить 0
        inj = 1;                                   //то вкл Инжектор
        digitalWrite(injPin, invI ^ inj);          //устанавливаем инверсию
        time1 = *pTime1;                           //выставить новое время впрыска
        past = micro;                              //присваеваем время ?
      }
      if (inj && micro - past >= time1) {          //если истекло время
        inj = 0;                                   //то выкл Инжектор
        digitalWrite(injPin, invI ^ inj);          //устанавливаем инверсию
      }
    }
}

Но проблема не в этом. Почему водитель в очень сложной дорожной обстановке не играет в шахматы, да хоть сам с собой. Наверно потому что если и есть у человека за рулем свободная минутка, секунда , то все равно не надо отвлекаться на что-то посторонее. Вот так и МК. Не надо перегружать МК лишними заданиями и тогда он все будет успевать. Пусть он лишний раз впустую пробежит в loop(), но точно найдет время когда надо включить и выключить инжектор.

Завелась, ласточка.

Пришлось вернутся к одной катушке.

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

Завелась на простом скече (пустом) и на 2 ардуинах.На меге инжектор на нано зажигание.

С потенциометром с сериал сбои идут или глохнет,а без него работает зараза как с родным даже без опережений.

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

С потенциометром происходят странные вещи.

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

Это то, о чём говорил DetSimen - расход стал отрицательным, движок замироточил бензином. Поздравляю!

А я думаю чет не глохнет странно