Exemplo n.º 1
0
/**Appends sender's buffer by two HEX bytes
 * \param i 8-bit value to be converted into hex
 */
static void build_i8h(uint8_t i)
{
#ifdef UART_BINARY
 append_tx_buff(i);           //1 байт
#else
 uart.send_buf[uart.send_size++] = PGM_GET_BYTE(&hdig[i/16]);          //старший байт HEX числа
 uart.send_buf[uart.send_size++] = PGM_GET_BYTE(&hdig[i%16]);          //младший байт HEX числа
#endif
}
Exemplo n.º 2
0
void bc_indication_mode(struct ecudata_t *d)
{
 uint8_t i = 5;
 if (!IOCFG_CHECK(IOP_BC_INPUT))
  return; //normal program execution

 //Check 5 times
 do
 {
  if (IOCFG_GET(IOP_BC_INPUT))
   return; //normal program execution
 }while(--i);

 //We are entered to the blink codes indication mode
 _DISABLE_INTERRUPT();
 ce_set_state(CE_STATE_OFF);

 vent_turnoff(d);                //turn off ventilator
 starter_set_blocking_state(1);  //block starter
 IOCFG_INIT(IOP_FL_PUMP, 0);     //turn off fuel pump
 IOCFG_INIT(IOP_IE, 0);          //turn off IE valve solenoid
 IOCFG_INIT(IOP_FE, 0);          //turn off power valve solenoid

 wdt_reset_timer();

 //delay 2 sec.
 delay_hom(20);

 //main loop
 for(;;)
 {
  uint16_t errors = 0;
  disp_start();

  delay_hom(7);

  //read errors
  eeprom_read(&errors, EEPROM_ECUERRORS_START, sizeof(uint16_t));

  for(i = 0; i < 16; ++i)
  {
   if (0 == PGM_GET_BYTE(&blink_codes[i]))
    continue;
   if (errors & (1 << i))
   {
    disp_code(PGM_GET_BYTE(&blink_codes[i]));
    delay_hom(20);
   }
  }

  delay_hom(20);
  wdt_reset_timer();
 }
}
Exemplo n.º 3
0
/**Appends sender's buffer by 4 HEX bytes
 * \param i 16-bit value to be converted into hex
 */
static void build_i16h(uint16_t i)
{
#ifdef UART_BINARY
 append_tx_buff(_AB(i,1));    //старший байт
 append_tx_buff(_AB(i,0));    //младший байт
#else
 uart.send_buf[uart.send_size++] = PGM_GET_BYTE(&hdig[_AB(i,1)/16]);   //старший байт HEX числа (старший байт)
 uart.send_buf[uart.send_size++] = PGM_GET_BYTE(&hdig[_AB(i,1)%16]);   //младший байт HEX числа (старший байт)
 uart.send_buf[uart.send_size++] = PGM_GET_BYTE(&hdig[_AB(i,0)/16]);   //старший байт HEX числа (младший байт)
 uart.send_buf[uart.send_size++] = PGM_GET_BYTE(&hdig[_AB(i,0)%16]);   //младший байт HEX числа (младший байт)
#endif
}
Exemplo n.º 4
0
// Реализует функцию коэффициента усиления аттенюатора от оборотов
// Возвращает код 0...63 соответсутвующий определенному коэфф. усиления
//(см. HIP9011 datasheet).
uint8_t knock_attenuator_function(struct ecudata_t* d)
{
 int16_t i, i1, rpm = d->sens.inst_frq;

 if (rpm < 200) rpm = 200; //200 - минимальное значение оборотов по оси

 i = (rpm - 200) / 60;   //60 - шаг по оборотам

 if (i >= (KC_ATTENUATOR_LOOKUP_TABLE_SIZE-1))
  i = i1 = (KC_ATTENUATOR_LOOKUP_TABLE_SIZE-1);
 else
  i1 = i + 1;

 return simple_interpolation(rpm, PGM_GET_BYTE(&fw_data.exdata.attenuator_table[i]),
        PGM_GET_BYTE(&fw_data.exdata.attenuator_table[i1]), (i * 60) + 200, 60) >> 4;
}
Exemplo n.º 5
0
/** Builds AT+PINx command in the sender's buffer
 * \param name Buffer containing password, 1-st byte of buffer contains size of string
 */
static void append_tx_buff_with_at_pass_cmd(uint8_t* pass)
{
 uint8_t i = 0;
 uart_reset_send_buff();
 for(; i < 6; ++i) uart_append_send_buff(PGM_GET_BYTE(&AT_PIN[i]));
 for(i = 0; i < pass[0]; ++i) uart_append_send_buff(pass[i+1]);
}
Exemplo n.º 6
0
/** Builds AT+NAMEx command in the sender's buffer
 * \param name Buffer containing name, 1-st byte of buffer contains size of string
 */
static void append_tx_buff_with_at_name_cmd(uint8_t* name)
{
 uint8_t i = 0;
 uart_reset_send_buff();
 for(; i < 7; ++i) uart_append_send_buff(PGM_GET_BYTE(&AT_NAME[i]));
 for(i = 0; i < name[0]; ++i) uart_append_send_buff(name[i+1]);
}
Exemplo n.º 7
0
/** Builds AT+BAUDx command in the sender's buffer
 * \param baud Baud rate code (see uart.h file for more information)
 */
static void append_tx_buff_with_at_baud_cmd(uint16_t baud)
{
 uint8_t i = 0;
 uart_reset_send_buff();
 for(; i < 7; ++i) uart_append_send_buff(PGM_GET_BYTE(&AT_BAUD[i]));
 if (baud == CBR_9600) uart_append_send_buff('4');
 else if (baud == CBR_19200) uart_append_send_buff('5');
 else if (baud == CBR_38400) uart_append_send_buff('6');
 else if (baud == CBR_57600) uart_append_send_buff('7');
}
Exemplo n.º 8
0
void eeprom_write_P(void _PGM *pgm_src, uint16_t eeaddr, uint16_t size)
{
 uint8_t _t;
 uint8_t _PGM *src = (uint8_t _PGM*)pgm_src;
 do
 {
  uint8_t byte = PGM_GET_BYTE(src);
  _t=_SAVE_INTERRUPT();
  _DISABLE_INTERRUPT();
  __EEPUT(eeaddr, byte);
  _RESTORE_INTERRUPT(_t);

  wdt_reset_timer();

  eeaddr++;
  src++;
 }while(--size);

 EEAR=0x000; //this will help to prevent corruption of EEPROM
}
Exemplo n.º 9
0
static void build_fs(uint8_t _PGM *romBuffer, uint8_t size)
{
 while(size--) append_tx_buff(PGM_GET_BYTE(romBuffer++));
}
Exemplo n.º 10
0
/**Main function of firmware - entry point */
MAIN()
{
 int16_t calc_adv_ang = 0; 
 uint8_t turnout_low_priority_errors_counter = 255;
 int16_t advance_angle_inhibitor_state = 0;
 retard_state_t retard_state;

 //подготовка структуры данных переменных состояния системы
 init_ecu_data(&edat);
 knklogic_init(&retard_state);

 //конфигурируем порты ввода/вывода
 ckps_init_ports();
 vent_init_ports();
 fuelecon_init_ports();
 idlecon_init_ports();
 starter_init_ports();
 ce_init_ports();
 knock_init_ports();
 jumper_init_ports();

 //если код программы испорчен - зажигаем СЕ
 if (crc16f(0, CODE_SIZE)!=PGM_GET_WORD(&fw_data.code_crc))
  ce_set_error(ECUERROR_PROGRAM_CODE_BROKEN);

 //читаем параметры
 load_eeprom_params(&edat);

#ifdef REALTIME_TABLES
 //load currently selected tables into RAM
 load_selected_tables_into_ram(&edat);
#endif

 //предварительная инициализация параметров сигнального процессора детонации
 knock_set_band_pass(edat.param.knock_bpf_frequency);
 knock_set_gain(PGM_GET_BYTE(&fw_data.exdata.attenuator_table[0]));
 knock_set_int_time_constant(edat.param.knock_int_time_const);

 if (edat.param.knock_use_knock_channel)
  if (!knock_module_initialize())
  {//чип сигнального процессора детонации неисправен - зажигаем СЕ
   ce_set_error(ECUERROR_KSP_CHIP_FAILED);
  }
 edat.use_knock_channel_prev = edat.param.knock_use_knock_channel;

 adc_init();

 //проводим несколько циклов измерения датчиков для инициализации данных
 meas_initial_measure(&edat);

 //снимаем блокировку стартера
 starter_set_blocking_state(0);

 //инициализируем UART
 uart_init(edat.param.uart_divisor);

 //инициализируем модуль ДПКВ
 ckps_init_state();
 ckps_set_cyl_number(edat.param.ckps_engine_cyl);
 ckps_set_edge_type(edat.param.ckps_edge_type);
 ckps_set_cogs_btdc(edat.param.ckps_cogs_btdc); //<--only partial initialization
#ifndef COIL_REGULATION
 ckps_set_ignition_cogs(edat.param.ckps_ignit_cogs);
#endif
 ckps_set_knock_window(edat.param.knock_k_wnd_begin_angle,edat.param.knock_k_wnd_end_angle);
 ckps_use_knock_channel(edat.param.knock_use_knock_channel);
 ckps_set_cogs_btdc(edat.param.ckps_cogs_btdc); //<--now valid initialization
 ckps_set_merge_outs(edat.param.merge_ign_outs);

 s_timer_init();
 vent_init_state();

 //разрешаем глобально прерывания
 _ENABLE_INTERRUPT();

 sop_init_operations();
 //------------------------------------------------------------------------
 while(1)
 {
  if (ckps_is_cog_changed())
   s_timer_set(engine_rotation_timeout_counter,ENGINE_ROTATION_TIMEOUT_VALUE);

  if (s_timer_is_action(engine_rotation_timeout_counter))
  { //двигатель остановился (его обороты ниже критических)
#ifdef COIL_REGULATION
   ckps_init_ports();           //чтобы IGBT не зависли в открытом состоянии
   //TODO: Сделать мягкую отсечку для избавления от нежелательной искры. Как?
#endif
   ckps_init_state_variables();
   edat.engine_mode = EM_START; //режим пуска

   if (edat.param.knock_use_knock_channel)
    knock_start_settings_latching();

   edat.curr_angle = calc_adv_ang;
   meas_update_values_buffers(&edat, 1);  //<-- update RPM only
  }

  //запускаем измерения АЦП, через равные промежутки времени. При обнаружении каждого рабочего
  //цикла этот таймер переинициализируется. Таким образом, когда частота вращения двигателя превысит
  //определенную величину, это условие выполнятся перестанет.
  if (s_timer_is_action(force_measure_timeout_counter))
  {
   if (!edat.param.knock_use_knock_channel)
   {
    _DISABLE_INTERRUPT();
    adc_begin_measure();
    _ENABLE_INTERRUPT();
   }
   else
   {
    //если сейчас происходит загрузка настроек в HIP, то нужно дождаться ее завершения.
    while(!knock_is_latching_idle());
    _DISABLE_INTERRUPT();
    //включаем режим интегрирования и ждем около 20мкс, пока интегратор начнет интегрировать (напряжение
    //на его выходе упадет до минимума). В данном случае нет ничего страшного в том, что мы держим прерывания
    //запрещенными 20-25мкс, так как это проискодит на очень маленьких оборотах.
    knock_set_integration_mode(KNOCK_INTMODE_INT);
    _DELAY_CYCLES(350);
    knock_set_integration_mode(KNOCK_INTMODE_HOLD);
    adc_begin_measure_all(); //измеряем сигнал с ДД тоже
    _ENABLE_INTERRUPT();
   }

   s_timer_set(force_measure_timeout_counter, FORCE_MEASURE_TIMEOUT_VALUE);
   meas_update_values_buffers(&edat, 0);
  }

  //----------непрерывное выполнение-----------------------------------------
  //выполнение отложенных операций
  sop_execute_operations(&edat);
  //управление фиксированием и индицированием возникающих ошибок
  ce_check_engine(&edat, &ce_control_time_counter);
  //обработка приходящих/уходящих данных последовательного порта
  process_uart_interface(&edat);
  //управление сохранением настроек
  save_param_if_need(&edat);
  //расчет мгновенной частоты вращения коленвала
  edat.sens.inst_frq = ckps_calculate_instant_freq();
  //усреднение физических величин хранящихся в кольцевых буферах
  meas_average_measured_values(&edat);
  //cчитываем дискретные входы системы и переключаем тип топлива
  meas_take_discrete_inputs(&edat);
  //управление периферией
  control_engine_units(&edat);
  //КА состояний системы (диспетчер режимов - сердце основного цикла)
  calc_adv_ang = advance_angle_state_machine(&edat);
  //добавляем к УОЗ октан-коррекцию
  calc_adv_ang+=edat.param.angle_corr;
  //ограничиваем получившийся УОЗ установленными пределами
  restrict_value_to(&calc_adv_ang, edat.param.min_angle, edat.param.max_angle);
  //Если стоит режим нулевого УОЗ, то 0
  if (edat.param.zero_adv_ang)
   calc_adv_ang = 0;

#ifdef COIL_REGULATION
  //calculate and update coil regulation time
  ckps_set_acc_time(accumulation_time(&edat));
#endif
  //Если разрешено, то делаем отсечку зажигания при превышении определенных оборотов
  if (edat.param.ign_cutoff)
   ckps_enable_ignition(edat.sens.inst_frq < edat.param.ign_cutoff_thrd);
  else
   ckps_enable_ignition(1);  
  //------------------------------------------------------------------------

  //выполняем операции которые необходимо выполнять строго для каждого рабочего цикла.
  if (ckps_is_cycle_cutover_r())
  {
   meas_update_values_buffers(&edat, 0);
   s_timer_set(force_measure_timeout_counter, FORCE_MEASURE_TIMEOUT_VALUE);

   //Ограничиваем быстрые изменения УОЗ, он не может изменится больше чем на определенную величину
   //за один рабочий цикл. В режиме пуска фильтр УОЗ отключен.
   if (EM_START == edat.engine_mode)
    edat.curr_angle = advance_angle_inhibitor_state = calc_adv_ang;
   else
    edat.curr_angle = advance_angle_inhibitor(calc_adv_ang, &advance_angle_inhibitor_state, edat.param.angle_inc_spead, edat.param.angle_dec_spead);

   //----------------------------------------------
   if (edat.param.knock_use_knock_channel)
   {
    knklogic_detect(&edat, &retard_state);
    knklogic_retard(&edat, &retard_state);
   }
   else
    edat.knock_retard = 0;
   //----------------------------------------------

   //сохраняем УОЗ для реализации в ближайшем по времени цикле зажигания
   ckps_set_advance_angle(edat.curr_angle);

   //управляем усилением аттенюатора в зависимости от оборотов
   if (edat.param.knock_use_knock_channel)
    knock_set_gain(knock_attenuator_function(&edat));

   // индицирование этих ошибок прекращаем при начале вращения двигателя
   //(при прошествии N-го количества циклов)
   if (turnout_low_priority_errors_counter == 1)
   {
    ce_clear_error(ECUERROR_EEPROM_PARAM_BROKEN);
    ce_clear_error(ECUERROR_PROGRAM_CODE_BROKEN);
   }
   if (turnout_low_priority_errors_counter > 0)
    turnout_low_priority_errors_counter--;
  }

 }//main loop
 //------------------------------------------------------------------------
}