Помогите объединить два скетча

Войдите на сайт для отправки комментариев

Нет ответов

Ср, 15/05/2013 - 14:39

ishved

Offline

Зарегистрирован: 06.03.2013

Есть рабочий скетч автомобильного расходомера

#include <EEPROM.h>
#include <LiquidCrystal.h>

#define LCD_RS_PIN 12
#define LCD_ENABLE_PIN 11
#define LCD_D4_PIN 5
#define LCD_D5_PIN 4
#define LCD_D6_PIN 3
#define LCD_D7_PIN 2

#define LED_PIN 13 // Вывод со светодиодом
//#define BANDAP_PIN 10 // Эталонный вход АЦП

#define RESET_GLOBAL_PIN 6 // Номер ноги для кнопки сброса расхода
#define SPEED_PIN 7 // Номер ноги для датчика скорости
#define INJECTOR_PIN 8 // Номер ноги для форсунки
#define CHECK_VOLTAGE_PIN A1 // Номер ноги, на которой измеряем напряжение для засекания отключения питания
#define CHECK_GABARIT_PIN 14 //Номер ноги, на которой изменяется напряжение при включении габаритов ********************************
#define DISP_PIN 9 //Номер ноги подключенный через конденсатор к подсветке дисплея *************************************************

#define PERIOD 1000000 // Период усреднения текущего расхода и обновления дисплея (микросекунды) - секунда

//#define BANDAP_VOLTAGE 1.1 // Эталонное напряжение на 14 входе АЦП
#define CRITICAL_VOLTAGE 3.0 // Напряжение, при котором начинаем быстренько записывать в EEPROM

#define IDLE_STROKE_DURATION 20000 // Суммарное время открытия форсунок (милисекунды) за период на холостом ходу
#define IDLE_STROKE_HOUR_CONSUMPTION 0.7 // Часовой расход топлива на холостом ходу (литры в час)
#define TEST_SPEED 60.0 // Контрольная скорость (километры в час) для расчёта коэффициента пробега
#define TEST_TICKS 84 // Число импульсов с датчика скорости за период на контрольной скорости

#define HOUR_PERIODS ( 3600000000.0 / PERIOD ) // Число периодов в часу
#define FUEL_FACTOR ( IDLE_STROKE_HOUR_CONSUMPTION / HOUR_PERIODS / IDLE_STROKE_DURATION ) // Коэффициент расхода топлива (литры) за период
#define RANGE_FACTOR ( TEST_SPEED / TEST_TICKS / HOUR_PERIODS ) // Коэффициент пробега (километры) за период
#define CONSUMPTION_FACTOR ( 100.0 * FUEL_FACTOR / RANGE_FACTOR ) // Коэффициент километрового расхода топлива (литры на 100 км)

#define TICKS_TRESHOLD 1 // Порог (импульсы датчика скорости) за период, выше которого можно считать километровый расход
#define DURATION_CORR 0 // Поправка при измерении длительности времени открытия одной форсунки (микросекунды)
#define AVG_LENGTH 10 // Число периодов для усреднения

#define AVG_REFRESH_TIME 1 // Время в часах, после которого сбрасывается усреднённый километровый расход, если не было сброса по расстоянию (1 час)
#define AVG_REFRESH_LENGTH 0.1 // Расстояние в километрах, после которого сбрасывается усреднённый километровый расход (100 м)
// #define AVG_REFRESH_PERIODS ( AVG_REFRESH_TIME * HOUR_PERIODS ) // Число периодов между обновлениями среднего расхода
#define AVG_REFRESH_PERIODS 60 // Число периодов между обновлениями среднего расхода
#define AVG_REFRESH_TICKS ( AVG_REFRESH_LENGTH / RANGE_FACTOR ) // Число импульсов датчика скорости между обновлениями среднего расхода
#define SHOW_GLOBAL_PERIODS 3 // Число периодов между переключениями общего и среднего (за 10 минут) расхода

// Строковые константы
// #define STR_AVG String(" Cp:")
// #define STR_CUR String("M\0:")

// #define STR_HR String("1:")
#define STR_AVG String("AVG:")
#define STR_CUR String("CUR:")
#define STR_HR String("HR:")
#define STR_GLOB String("GL:")
 
#define STR_NA String(" n/a")
#define STR_KMH String("km/h")
 
 

LiquidCrystal lcd(LCD_RS_PIN, LCD_ENABLE_PIN, LCD_D4_PIN, LCD_D5_PIN, LCD_D6_PIN, LCD_D7_PIN);
int GabaritState = 0; //Переменная для хранения состояния габаритов **************************************************

unsigned long dur;
unsigned long dur_t;
unsigned long t;

boolean last_injector_state;
boolean last_speed_state;
boolean last_reset_global_state;

unsigned long total_duration;
unsigned long total_ticks;
unsigned long total_avg_duration;
unsigned long total_avg_ticks;
unsigned long d_avg_duration;
unsigned long d_avg_ticks;
unsigned long global_avg_duration;
unsigned long global_avg_ticks;
int period_counter;
// int period_counter2;

boolean eeprom_already_written;
boolean show_global;
int show_global_counter;

// Структура, описывающая данные для усреднения
struct consumption_data {
  unsigned long duration;
  unsigned long ticks; 
};

byte gauge_0[] = {
  B00000000,
  B00000000,
  B00000000,
  B00000000,
  B00000000,
  B00000000,
  B00000000,
  B11111111
};

byte gauge_1[] = {
  B00000000,
  B00000000,
  B00000000,
  B00000000,
  B00000000,
  B00000000,
  B11111111,
  B11111111
};

byte gauge_2[] = {
  B00000000,
  B00000000,
  B00000000,
  B00000000,
  B00000000,
  B11111111,
  B11111111,
  B11111111
};

byte gauge_3[] = {
  B00000000,
  B00000000,
  B00000000,
  B00000000,
  B11111111,
  B11111111,
  B11111111,
  B11111111
};

byte gauge_4[] = {
  B00000000,
  B00000000,
  B00000000,
  B11111111,
  B11111111,
  B11111111,
  B11111111,
  B11111111
};

byte gauge_5[] = {
  B00000000,
  B00000000,
  B11111111,
  B11111111,
  B11111111,
  B11111111,
  B11111111,
  B11111111
};

byte gauge_6[] = {
  B00000000,
  B11111111,
  B11111111,
  B11111111,
  B11111111,
  B11111111,
  B11111111,
  B11111111
};

byte gauge_7[] = {
  B11111111,
  B11111111,
  B11111111,
  B11111111,
  B11111111,
  B11111111,
  B11111111,
  B11111111
};

struct consumption_data data[AVG_LENGTH];
int avg_counter;

void setup() {
  {
  // инициализируем пин, подключенный к подсветке, как выход ******************************************
  pinMode(DISP_PIN, OUTPUT);     
  // инициализируем пин, подключенный к габаритам, как вход********************************************
  pinMode(CHECK_GABARIT_PIN, INPUT);   
}

  //Serial.begin(9600);
pinMode(9, OUTPUT);  //Выход на габариты
analogWrite(9, 150);   // устанавливаем ШИМ выход   
  // Инициализация дисплея
  lcd.begin(16, 2);
  
  // Загрузка пользовательских символов для отрисовки шкалы
  lcd.createChar(0, gauge_0);
  lcd.createChar(1, gauge_1);
  lcd.createChar(2, gauge_2);
  lcd.createChar(3, gauge_3);
  lcd.createChar(4, gauge_4);
  lcd.createChar(5, gauge_5);
  lcd.createChar(6, gauge_6);
  lcd.createChar(7, gauge_7);
  
  pinMode(INJECTOR_PIN, INPUT);
  pinMode(SPEED_PIN, INPUT);
  pinMode(RESET_GLOBAL_PIN, INPUT);
  pinMode(CHECK_VOLTAGE_PIN, INPUT);
  pinMode(LED_PIN, OUTPUT);

 digitalWrite(SPEED_PIN, HIGH);
 digitalWrite(INJECTOR_PIN, HIGH);  
 digitalWrite(RESET_GLOBAL_PIN, LOW);
  
  //last_injector_state = analogRead(INJECTOR_PIN) < 500;
  //last_speed_state = analogRead(SPEED_PIN) < 500;
  last_reset_global_state = digitalRead(RESET_GLOBAL_PIN);

  // Инициализация данных для усреднения
  for (int i=0; i < AVG_LENGTH; ++i) {
    data[i].duration = 0;
    data[i].ticks = 0;
  }

  dur = 0;
  dur_t = micros();
  t = dur_t + PERIOD;
  
  total_duration = 0;
  total_ticks = 0;
  total_avg_duration = total_duration;
  total_avg_ticks = total_ticks;
  d_avg_duration = total_duration;
  d_avg_ticks = total_ticks;
  
  for (int i = 0; i < sizeof(unsigned long int); ++i) {
    *( (byte*)(&global_avg_duration) + i ) = EEPROM.read(i);
  }
  
  int addr = sizeof(unsigned long int);

  for (int i = 0; i < sizeof(unsigned long int); ++i) {
    *( (byte*)(&global_avg_ticks) + i ) = EEPROM.read(addr + i);
  }
  
  /* global_avg_duration = 0;
  global_avg_ticks = 0; */
    
  period_counter = 0;
//   period_counter2 = 0;
  avg_counter = 0;
  show_global = false;
  show_global_counter = 0;
  
  eeprom_already_written = true;
}

void loop() {
 float realv = (5.0 / 1024.0 * analogRead(2))*19; //+++++++++++++++++++++++++++++++++++++++++++++++++++++
  GabaritState = digitalRead(CHECK_GABARIT_PIN); //**************************************************
  // проверяем вкличены габариты
  // если вкличены, то buttonState будет HIGH:
  if (GabaritState == HIGH) {   
    // включаем подсветку   
 analogWrite(DISP_PIN, 135);   // устанавливаем ШИМ выход 
  }
  else {
    // выключаем подсветку
   analogWrite(DISP_PIN, 155);   // устанавливаем ШИМ выход *******************************************
  }
 // float vcc_voltage = BANDAP_VOLTAGE * 1024 / analogRead(BANDAP_PIN);
  float check_voltage = 5.0 * analogRead(CHECK_VOLTAGE_PIN) / 1024;
  
/*  boolean injector_state = analogRead(INJECTOR_PIN) < 500;
  boolean speed_state = analogRead(SPEED_PIN) < 500;*/

  boolean injector_state = !digitalRead(INJECTOR_PIN);
  boolean speed_state = digitalRead(SPEED_PIN);

  boolean reset_global_state = digitalRead(RESET_GLOBAL_PIN);
  unsigned long new_t = micros();
  
  // if (vcc_voltage < CRITICAL_VOLTAGE) {
  if (check_voltage < CRITICAL_VOLTAGE) {
    if (!eeprom_already_written) {
      digitalWrite(LED_PIN, HIGH);
      
      // Быстренько записываем в ПЗУ данные о среднем расходе
      
      for ( int i = 0; i < sizeof(unsigned long int); ++i ) {
        EEPROM.write(i, *( (byte*)(&global_avg_duration) + i) );
      }
      
      int addr = sizeof(unsigned long int);

      for ( int i = 0; i < sizeof(unsigned long int); ++i ) {
        EEPROM.write(addr + i, *( (byte*)(&global_avg_ticks) + i) );
      }
      
      eeprom_already_written = true;
      
      digitalWrite(LED_PIN, LOW);
    }
    
  } else {
    eeprom_already_written = false;
  }
  
  // Вычисление мгновенных значений
  
  if (injector_state != last_injector_state) {
    if (injector_state) {
      dur = new_t - dur_t;
      if (dur) dur += DURATION_CORR; // Поправочка
      total_duration += dur;
    } else {
      dur_t = new_t;
      dur = 0;
    }
    
    last_injector_state = injector_state;
  }
  
  if (speed_state != last_speed_state) {
    total_ticks++;
    
    last_speed_state = speed_state;
  }
  
  if (last_reset_global_state == HIGH && reset_global_state == LOW) {
    global_avg_duration = 0;
    global_avg_ticks = 0;
    
    digitalWrite(LED_PIN, HIGH);
  }
  
  if (last_reset_global_state == LOW && reset_global_state == HIGH) {
    digitalWrite(LED_PIN, LOW);
  }
  
  last_reset_global_state = reset_global_state;
  
  // Действия, которые выполняются раз в секунду
  
  if (new_t >= t) {
    if (!dur) {
      dur = new_t - dur_t;
      if (dur) dur += DURATION_CORR; // Поправочка
      total_duration += dur;
    }
    
    // Отладочная установка значений
    
   // total_duration = 100000; //ПРИ ЗАПУСКЕ ЗАКОМЕНТИРОВАТЬ
    //total_ticks = 56;
    
    d_avg_duration += total_duration;
    d_avg_ticks += total_ticks;
    
    global_avg_duration += total_duration / 1000;
    global_avg_ticks += total_ticks;
    
    ++period_counter;
    // ++period_counter2;
    
    // if (d_avg_ticks >= AVG_REFRESH_TICKS || period_counter >= AVG_REFRESH_PERIODS) {
    if (period_counter >= AVG_REFRESH_PERIODS) {
      // Вычисление средних значений
      
      total_avg_duration += d_avg_duration;
      total_avg_duration -= data[avg_counter].duration;
      
      total_avg_ticks += d_avg_ticks;
      total_avg_ticks -= data[avg_counter].ticks;
            
      data[avg_counter].duration = d_avg_duration;
      data[avg_counter].ticks = d_avg_ticks;

//      total_avg_duration = 0;
//      total_avg_ticks = 0;
      
//      for (int i = 0; i < AVG_LENGTH; ++i) {
//        total_avg_duration += data[i].duration;
//        total_avg_ticks += data[i].ticks;
//      }
      
      // Отладочный вывод
      //Serial.println(total_duration, DEC);
      //Serial.println(total_ticks, DEC);
      //Serial.println(d_avg_duration, DEC);
      //Serial.println(d_avg_ticks, DEC);
     // Serial.println(total_avg_duration, DEC);
     // Serial.println(total_avg_ticks, DEC);
      
      period_counter = 0;
      d_avg_duration = 0;
      d_avg_ticks = 0;

      ++avg_counter;
      if (avg_counter >= AVG_LENGTH)
        avg_counter = 0;
    }
    
    // Конвертация значений в физические единицы и вывод на экран

    String s1, s2, s3, s4;
    unsigned int consumption = 0;
    unsigned int avg_consumption = 0;
    unsigned int global_avg_consumption = 0;
    
    if (total_ticks > TICKS_TRESHOLD) {
      consumption = 10.0 * CONSUMPTION_FACTOR * total_duration / total_ticks;
    }

    if (total_avg_ticks > TICKS_TRESHOLD) {
      avg_consumption = 10.0 * CONSUMPTION_FACTOR * total_avg_duration / total_avg_ticks;
    }

    if (global_avg_ticks > TICKS_TRESHOLD) {
      global_avg_consumption = 10000.0 * CONSUMPTION_FACTOR * global_avg_duration / global_avg_ticks;
    }
    
    unsigned int hour_consumption = 10.0 * FUEL_FACTOR * total_duration * HOUR_PERIODS;
    unsigned int spd = RANGE_FACTOR * total_ticks * HOUR_PERIODS;
    
    s1 = String(total_duration, DEC);

    if (total_ticks > TICKS_TRESHOLD) {
      s1 = STR_CUR + format(consumption);
      // s1 = STR_HR + format(hour_consumption);
      // s1 = format(consumption);
    } else {
      // s1 = STR_CUR + STR_NA;
      // s1 = STR_HR + STR_NA;
      // s1 = "n/a ";
      s1 = STR_HR + format(hour_consumption);
    }

    if (total_avg_ticks > TICKS_TRESHOLD) {
      s2 = STR_AVG + format(avg_consumption);
      // s2 = STR_KM + format(avg_consumption);
      // s2 = format(avg_consumption);
    } else {
      s2 = STR_AVG + STR_NA;
      // s2 = STR_KM + STR_NA;
      // s2 = "n/a ";
    }

    if (global_avg_ticks > TICKS_TRESHOLD) {
      s4 = STR_GLOB + format(global_avg_consumption);
    } else {
      s4 = STR_GLOB + STR_NA;
    }
    
    byte gauge_level = round(float(hour_consumption) / 10.0);
    byte c1;
    byte c2;
    
    if (gauge_level > 8) {
       c1 = 7;
       c2 = gauge_level - 9;
       if (c2 > 7) c2 = 7;
    } else if (gauge_level > 0) {
      c1 = gauge_level - 1;
      c2 = ' ';
    } else {
      c1 = ' ';
      c2 = ' ';
    }
    
    // s2 = "hr: " + format(hour_consumption);
    // s2 = format(hour_consumption);
    
    // s3 = "sp: " + String(spd, DEC);
    // s3 = String(spd, DEC);
    // s3 = String(total_ticks, DEC);
    
    // int iters = 3 - s3.length();
    // int iters = 8 - s3.length();
    
    // for(int i = 0; i < iters; ++i)
    //  s3 = " " + s3;
      
    // int iters2 = 8 - s1.length();
    
    // for(int i = 0; i < iters2; ++i)
    //  s1 = " " + s1;
    lcd.setCursor(11, 1); //+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
    lcd.print(realv);      //++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
    lcd.print("V"); //++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
    //s3 += STR_KMH;
    
    lcd.setCursor(1,0);
    lcd.print( show_global ? s4 : s2 );
    
    if (show_global_counter > SHOW_GLOBAL_PERIODS) {
      show_global = !show_global;
      show_global_counter = 0;
    }
    
    show_global_counter++;
    
    lcd.setCursor(1,1);
    lcd.print(s1);
    
    lcd.setCursor(0, 1);
    lcd.write(c1);  //Заменил print ha write

    lcd.setCursor(0, 0);
    lcd.write(c2);
        
    total_duration = 0;
    total_ticks = 0;
    t = new_t + PERIOD;
     
   
 }
}
  

String format(unsigned int dec) {
  if (dec > 1000) return String("##.#");
  
  unsigned int intPart = dec / 10;
  unsigned int fracPart = dec % 10;
  String result = String(intPart, DEC) + "," + String(fracPart, DEC);

  int iters = 4 - result.length();  
  for(int i = 0; i < iters; ++i)
    result = " " + result;

  return result;
}

Хочу добавить отображение температуры за бортом

#include <LiquidCrystal.h> 
#include <OneWire.h>          
#include <EEPROM.h>         
byte gradus[8] = 
{ 
  B00110, 
  B01001, 
  B01001, 
  B00110, 
  B00000, 
  B00000, 
  B00000, 
  B00000, 
}; // создаем собственный символ "градус Цельсия" 
byte i;                    
byte n;                  
byte m=0;                  
byte t=0;                  
int T[]={0,0,0,0};        
int Tp[]={0,0,0,0};     
int TD[]={0,0,0,0};

byte data[9];              
byte TotalDS=0;             
byte addr[4][8] = {       
   {0,0,0,0,0,0,0,0},       
   {0,0,0,0,0,0,0,0},
   {0,0,0,0,0,0,0,0},
   {0,0,0,0,0,0,0,0},
};  
OneWire  ds(10);            
LiquidCrystal lcd(12, 11, 5, 4, 3, 2);  

void setup()         
{
  lcd.begin(16, 2);
 
}
   void Menu() {           
     lcd.clear(); 

lcd.createChar(1, gradus); // присваиваем символу "градус Целься" порядковый номер
       lcd.setCursor(11, 0);
        lcd.print("T1:");           
        lcd.print(T[0]);
        lcd.print("\1C"); //символ "градус Цельсия"            
        i = 0;
        n=0;
        while (i != 1 ) 
        {
          if ( ds.search(addr[n]) != 1) { 
          
            ds.reset_search();
            i = 1; }
          else {        
            n++;         
            TotalDS = n; 
          }
        }
        }
void Gettemp() {
 ds.reset();       
    ds.write(0xCC,1);    
    ds.write(0x44,1);        
    for( n = 1; n < 90; n++) { 
      delay(10);            
      
    }
    for( n = 0; n < 4; n++) {  
      ds.reset();               
      ds.select(addr[n]);       
      
      ds.write(0xBE);          
      for ( i = 0; i < 9; i++) {data[i] = ds.read();} 
      Tp[n] = float((data[1] << 8) + data[0])/16.0;    
      
      if (Tp[n] == 85) {} else {T[n]=Tp[n];}         
          }

byte write_DS() ;{              
  for (i=0; i<8; i++) {        
    if (m==0) {EEPROM.write(128+t*8+i,0);} 
    else {EEPROM.write(128+t*8+i,addr[m-1][i]);}
  }
}

byte read_DS(); {              
  for (n=0; n<4; n++) {       
    for (i=0; i<8; i++) {      
      addr[n][i] = EEPROM.read(128+n*8+i); 
    }
  }
}
}

void loop()  
{
  Menu();
   Gettemp();
   
   
}

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

Arduino.ru

Регистрация новых пользователей и создание новых тем теперь только на новом форуме https://forum.arduino.ru

Помогите объединить два скетча