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

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

Нет ответов

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

ishved

Offline

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

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

001#include <EEPROM.h>
002#include <LiquidCrystal.h>
003 
004#define LCD_RS_PIN 12
005#define LCD_ENABLE_PIN 11
006#define LCD_D4_PIN 5
007#define LCD_D5_PIN 4
008#define LCD_D6_PIN 3
009#define LCD_D7_PIN 2
010 
011#define LED_PIN 13 // Вывод со светодиодом
012//#define BANDAP_PIN 10 // Эталонный вход АЦП
013 
014#define RESET_GLOBAL_PIN 6 // Номер ноги для кнопки сброса расхода
015#define SPEED_PIN 7 // Номер ноги для датчика скорости
016#define INJECTOR_PIN 8 // Номер ноги для форсунки
017#define CHECK_VOLTAGE_PIN A1 // Номер ноги, на которой измеряем напряжение для засекания отключения питания
018#define CHECK_GABARIT_PIN 14 //Номер ноги, на которой изменяется напряжение при включении габаритов ********************************
019#define DISP_PIN 9 //Номер ноги подключенный через конденсатор к подсветке дисплея *************************************************
020 
021#define PERIOD 1000000 // Период усреднения текущего расхода и обновления дисплея (микросекунды) - секунда
022 
023//#define BANDAP_VOLTAGE 1.1 // Эталонное напряжение на 14 входе АЦП
024#define CRITICAL_VOLTAGE 3.0 // Напряжение, при котором начинаем быстренько записывать в EEPROM
025 
026#define IDLE_STROKE_DURATION 20000 // Суммарное время открытия форсунок (милисекунды) за период на холостом ходу
027#define IDLE_STROKE_HOUR_CONSUMPTION 0.7 // Часовой расход топлива на холостом ходу (литры в час)
028#define TEST_SPEED 60.0 // Контрольная скорость (километры в час) для расчёта коэффициента пробега
029#define TEST_TICKS 84 // Число импульсов с датчика скорости за период на контрольной скорости
030 
031#define HOUR_PERIODS ( 3600000000.0 / PERIOD ) // Число периодов в часу
032#define FUEL_FACTOR ( IDLE_STROKE_HOUR_CONSUMPTION / HOUR_PERIODS / IDLE_STROKE_DURATION ) // Коэффициент расхода топлива (литры) за период
033#define RANGE_FACTOR ( TEST_SPEED / TEST_TICKS / HOUR_PERIODS ) // Коэффициент пробега (километры) за период
034#define CONSUMPTION_FACTOR ( 100.0 * FUEL_FACTOR / RANGE_FACTOR ) // Коэффициент километрового расхода топлива (литры на 100 км)
035 
036#define TICKS_TRESHOLD 1 // Порог (импульсы датчика скорости) за период, выше которого можно считать километровый расход
037#define DURATION_CORR 0 // Поправка при измерении длительности времени открытия одной форсунки (микросекунды)
038#define AVG_LENGTH 10 // Число периодов для усреднения
039 
040#define AVG_REFRESH_TIME 1 // Время в часах, после которого сбрасывается усреднённый километровый расход, если не было сброса по расстоянию (1 час)
041#define AVG_REFRESH_LENGTH 0.1 // Расстояние в километрах, после которого сбрасывается усреднённый километровый расход (100 м)
042// #define AVG_REFRESH_PERIODS ( AVG_REFRESH_TIME * HOUR_PERIODS ) // Число периодов между обновлениями среднего расхода
043#define AVG_REFRESH_PERIODS 60 // Число периодов между обновлениями среднего расхода
044#define AVG_REFRESH_TICKS ( AVG_REFRESH_LENGTH / RANGE_FACTOR ) // Число импульсов датчика скорости между обновлениями среднего расхода
045#define SHOW_GLOBAL_PERIODS 3 // Число периодов между переключениями общего и среднего (за 10 минут) расхода
046 
047// Строковые константы
048// #define STR_AVG String(" Cp:")
049// #define STR_CUR String("M\0:")
050 
051// #define STR_HR String("1:")
052#define STR_AVG String("AVG:")
053#define STR_CUR String("CUR:")
054#define STR_HR String("HR:")
055#define STR_GLOB String("GL:")
056  
057#define STR_NA String(" n/a")
058#define STR_KMH String("km/h")
059  
060  
061 
062LiquidCrystal lcd(LCD_RS_PIN, LCD_ENABLE_PIN, LCD_D4_PIN, LCD_D5_PIN, LCD_D6_PIN, LCD_D7_PIN);
063int GabaritState = 0; //Переменная для хранения состояния габаритов **************************************************
064 
065unsigned long dur;
066unsigned long dur_t;
067unsigned long t;
068 
069boolean last_injector_state;
070boolean last_speed_state;
071boolean last_reset_global_state;
072 
073unsigned long total_duration;
074unsigned long total_ticks;
075unsigned long total_avg_duration;
076unsigned long total_avg_ticks;
077unsigned long d_avg_duration;
078unsigned long d_avg_ticks;
079unsigned long global_avg_duration;
080unsigned long global_avg_ticks;
081int period_counter;
082// int period_counter2;
083 
084boolean eeprom_already_written;
085boolean show_global;
086int show_global_counter;
087 
088// Структура, описывающая данные для усреднения
089struct consumption_data {
090  unsigned long duration;
091  unsigned long ticks; 
092};
093 
094byte gauge_0[] = {
095  B00000000,
096  B00000000,
097  B00000000,
098  B00000000,
099  B00000000,
100  B00000000,
101  B00000000,
102  B11111111
103};
104 
105byte gauge_1[] = {
106  B00000000,
107  B00000000,
108  B00000000,
109  B00000000,
110  B00000000,
111  B00000000,
112  B11111111,
113  B11111111
114};
115 
116byte gauge_2[] = {
117  B00000000,
118  B00000000,
119  B00000000,
120  B00000000,
121  B00000000,
122  B11111111,
123  B11111111,
124  B11111111
125};
126 
127byte gauge_3[] = {
128  B00000000,
129  B00000000,
130  B00000000,
131  B00000000,
132  B11111111,
133  B11111111,
134  B11111111,
135  B11111111
136};
137 
138byte gauge_4[] = {
139  B00000000,
140  B00000000,
141  B00000000,
142  B11111111,
143  B11111111,
144  B11111111,
145  B11111111,
146  B11111111
147};
148 
149byte gauge_5[] = {
150  B00000000,
151  B00000000,
152  B11111111,
153  B11111111,
154  B11111111,
155  B11111111,
156  B11111111,
157  B11111111
158};
159 
160byte gauge_6[] = {
161  B00000000,
162  B11111111,
163  B11111111,
164  B11111111,
165  B11111111,
166  B11111111,
167  B11111111,
168  B11111111
169};
170 
171byte gauge_7[] = {
172  B11111111,
173  B11111111,
174  B11111111,
175  B11111111,
176  B11111111,
177  B11111111,
178  B11111111,
179  B11111111
180};
181 
182struct consumption_data data[AVG_LENGTH];
183int avg_counter;
184 
185void setup() {
186  {
187  // инициализируем пин, подключенный к подсветке, как выход ******************************************
188  pinMode(DISP_PIN, OUTPUT);     
189  // инициализируем пин, подключенный к габаритам, как вход********************************************
190  pinMode(CHECK_GABARIT_PIN, INPUT);   
191}
192 
193  //Serial.begin(9600);
194pinMode(9, OUTPUT);  //Выход на габариты
195analogWrite(9, 150);   // устанавливаем ШИМ выход   
196  // Инициализация дисплея
197  lcd.begin(16, 2);
198   
199  // Загрузка пользовательских символов для отрисовки шкалы
200  lcd.createChar(0, gauge_0);
201  lcd.createChar(1, gauge_1);
202  lcd.createChar(2, gauge_2);
203  lcd.createChar(3, gauge_3);
204  lcd.createChar(4, gauge_4);
205  lcd.createChar(5, gauge_5);
206  lcd.createChar(6, gauge_6);
207  lcd.createChar(7, gauge_7);
208   
209  pinMode(INJECTOR_PIN, INPUT);
210  pinMode(SPEED_PIN, INPUT);
211  pinMode(RESET_GLOBAL_PIN, INPUT);
212  pinMode(CHECK_VOLTAGE_PIN, INPUT);
213  pinMode(LED_PIN, OUTPUT);
214 
215 digitalWrite(SPEED_PIN, HIGH);
216 digitalWrite(INJECTOR_PIN, HIGH);  
217 digitalWrite(RESET_GLOBAL_PIN, LOW);
218   
219  //last_injector_state = analogRead(INJECTOR_PIN) < 500;
220  //last_speed_state = analogRead(SPEED_PIN) < 500;
221  last_reset_global_state = digitalRead(RESET_GLOBAL_PIN);
222 
223  // Инициализация данных для усреднения
224  for (int i=0; i < AVG_LENGTH; ++i) {
225    data[i].duration = 0;
226    data[i].ticks = 0;
227  }
228 
229  dur = 0;
230  dur_t = micros();
231  t = dur_t + PERIOD;
232   
233  total_duration = 0;
234  total_ticks = 0;
235  total_avg_duration = total_duration;
236  total_avg_ticks = total_ticks;
237  d_avg_duration = total_duration;
238  d_avg_ticks = total_ticks;
239   
240  for (int i = 0; i < sizeof(unsigned long int); ++i) {
241    *( (byte*)(&global_avg_duration) + i ) = EEPROM.read(i);
242  }
243   
244  int addr = sizeof(unsigned long int);
245 
246  for (int i = 0; i < sizeof(unsigned long int); ++i) {
247    *( (byte*)(&global_avg_ticks) + i ) = EEPROM.read(addr + i);
248  }
249   
250  /* global_avg_duration = 0;
251  global_avg_ticks = 0; */
252     
253  period_counter = 0;
254//   period_counter2 = 0;
255  avg_counter = 0;
256  show_global = false;
257  show_global_counter = 0;
258   
259  eeprom_already_written = true;
260}
261 
262void loop() {
263 float realv = (5.0 / 1024.0 * analogRead(2))*19; //+++++++++++++++++++++++++++++++++++++++++++++++++++++
264  GabaritState = digitalRead(CHECK_GABARIT_PIN); //**************************************************
265  // проверяем вкличены габариты
266  // если вкличены, то buttonState будет HIGH:
267  if (GabaritState == HIGH) {   
268    // включаем подсветку   
269 analogWrite(DISP_PIN, 135);   // устанавливаем ШИМ выход 
270  }
271  else {
272    // выключаем подсветку
273   analogWrite(DISP_PIN, 155);   // устанавливаем ШИМ выход *******************************************
274  }
275 // float vcc_voltage = BANDAP_VOLTAGE * 1024 / analogRead(BANDAP_PIN);
276  float check_voltage = 5.0 * analogRead(CHECK_VOLTAGE_PIN) / 1024;
277   
278/*  boolean injector_state = analogRead(INJECTOR_PIN) < 500;
279  boolean speed_state = analogRead(SPEED_PIN) < 500;*/
280 
281  boolean injector_state = !digitalRead(INJECTOR_PIN);
282  boolean speed_state = digitalRead(SPEED_PIN);
283 
284  boolean reset_global_state = digitalRead(RESET_GLOBAL_PIN);
285  unsigned long new_t = micros();
286   
287  // if (vcc_voltage < CRITICAL_VOLTAGE) {
288  if (check_voltage < CRITICAL_VOLTAGE) {
289    if (!eeprom_already_written) {
290      digitalWrite(LED_PIN, HIGH);
291       
292      // Быстренько записываем в ПЗУ данные о среднем расходе
293       
294      for ( int i = 0; i < sizeof(unsigned long int); ++i ) {
295        EEPROM.write(i, *( (byte*)(&global_avg_duration) + i) );
296      }
297       
298      int addr = sizeof(unsigned long int);
299 
300      for ( int i = 0; i < sizeof(unsigned long int); ++i ) {
301        EEPROM.write(addr + i, *( (byte*)(&global_avg_ticks) + i) );
302      }
303       
304      eeprom_already_written = true;
305       
306      digitalWrite(LED_PIN, LOW);
307    }
308     
309  } else {
310    eeprom_already_written = false;
311  }
312   
313  // Вычисление мгновенных значений
314   
315  if (injector_state != last_injector_state) {
316    if (injector_state) {
317      dur = new_t - dur_t;
318      if (dur) dur += DURATION_CORR; // Поправочка
319      total_duration += dur;
320    } else {
321      dur_t = new_t;
322      dur = 0;
323    }
324     
325    last_injector_state = injector_state;
326  }
327   
328  if (speed_state != last_speed_state) {
329    total_ticks++;
330     
331    last_speed_state = speed_state;
332  }
333   
334  if (last_reset_global_state == HIGH && reset_global_state == LOW) {
335    global_avg_duration = 0;
336    global_avg_ticks = 0;
337     
338    digitalWrite(LED_PIN, HIGH);
339  }
340   
341  if (last_reset_global_state == LOW && reset_global_state == HIGH) {
342    digitalWrite(LED_PIN, LOW);
343  }
344   
345  last_reset_global_state = reset_global_state;
346   
347  // Действия, которые выполняются раз в секунду
348   
349  if (new_t >= t) {
350    if (!dur) {
351      dur = new_t - dur_t;
352      if (dur) dur += DURATION_CORR; // Поправочка
353      total_duration += dur;
354    }
355     
356    // Отладочная установка значений
357     
358   // total_duration = 100000; //ПРИ ЗАПУСКЕ ЗАКОМЕНТИРОВАТЬ
359    //total_ticks = 56;
360     
361    d_avg_duration += total_duration;
362    d_avg_ticks += total_ticks;
363     
364    global_avg_duration += total_duration / 1000;
365    global_avg_ticks += total_ticks;
366     
367    ++period_counter;
368    // ++period_counter2;
369     
370    // if (d_avg_ticks >= AVG_REFRESH_TICKS || period_counter >= AVG_REFRESH_PERIODS) {
371    if (period_counter >= AVG_REFRESH_PERIODS) {
372      // Вычисление средних значений
373       
374      total_avg_duration += d_avg_duration;
375      total_avg_duration -= data[avg_counter].duration;
376       
377      total_avg_ticks += d_avg_ticks;
378      total_avg_ticks -= data[avg_counter].ticks;
379             
380      data[avg_counter].duration = d_avg_duration;
381      data[avg_counter].ticks = d_avg_ticks;
382 
383//      total_avg_duration = 0;
384//      total_avg_ticks = 0;
385       
386//      for (int i = 0; i < AVG_LENGTH; ++i) {
387//        total_avg_duration += data[i].duration;
388//        total_avg_ticks += data[i].ticks;
389//      }
390       
391      // Отладочный вывод
392      //Serial.println(total_duration, DEC);
393      //Serial.println(total_ticks, DEC);
394      //Serial.println(d_avg_duration, DEC);
395      //Serial.println(d_avg_ticks, DEC);
396     // Serial.println(total_avg_duration, DEC);
397     // Serial.println(total_avg_ticks, DEC);
398       
399      period_counter = 0;
400      d_avg_duration = 0;
401      d_avg_ticks = 0;
402 
403      ++avg_counter;
404      if (avg_counter >= AVG_LENGTH)
405        avg_counter = 0;
406    }
407     
408    // Конвертация значений в физические единицы и вывод на экран
409 
410    String s1, s2, s3, s4;
411    unsigned int consumption = 0;
412    unsigned int avg_consumption = 0;
413    unsigned int global_avg_consumption = 0;
414     
415    if (total_ticks > TICKS_TRESHOLD) {
416      consumption = 10.0 * CONSUMPTION_FACTOR * total_duration / total_ticks;
417    }
418 
419    if (total_avg_ticks > TICKS_TRESHOLD) {
420      avg_consumption = 10.0 * CONSUMPTION_FACTOR * total_avg_duration / total_avg_ticks;
421    }
422 
423    if (global_avg_ticks > TICKS_TRESHOLD) {
424      global_avg_consumption = 10000.0 * CONSUMPTION_FACTOR * global_avg_duration / global_avg_ticks;
425    }
426     
427    unsigned int hour_consumption = 10.0 * FUEL_FACTOR * total_duration * HOUR_PERIODS;
428    unsigned int spd = RANGE_FACTOR * total_ticks * HOUR_PERIODS;
429     
430    s1 = String(total_duration, DEC);
431 
432    if (total_ticks > TICKS_TRESHOLD) {
433      s1 = STR_CUR + format(consumption);
434      // s1 = STR_HR + format(hour_consumption);
435      // s1 = format(consumption);
436    } else {
437      // s1 = STR_CUR + STR_NA;
438      // s1 = STR_HR + STR_NA;
439      // s1 = "n/a ";
440      s1 = STR_HR + format(hour_consumption);
441    }
442 
443    if (total_avg_ticks > TICKS_TRESHOLD) {
444      s2 = STR_AVG + format(avg_consumption);
445      // s2 = STR_KM + format(avg_consumption);
446      // s2 = format(avg_consumption);
447    } else {
448      s2 = STR_AVG + STR_NA;
449      // s2 = STR_KM + STR_NA;
450      // s2 = "n/a ";
451    }
452 
453    if (global_avg_ticks > TICKS_TRESHOLD) {
454      s4 = STR_GLOB + format(global_avg_consumption);
455    } else {
456      s4 = STR_GLOB + STR_NA;
457    }
458     
459    byte gauge_level = round(float(hour_consumption) / 10.0);
460    byte c1;
461    byte c2;
462     
463    if (gauge_level > 8) {
464       c1 = 7;
465       c2 = gauge_level - 9;
466       if (c2 > 7) c2 = 7;
467    } else if (gauge_level > 0) {
468      c1 = gauge_level - 1;
469      c2 = ' ';
470    } else {
471      c1 = ' ';
472      c2 = ' ';
473    }
474     
475    // s2 = "hr: " + format(hour_consumption);
476    // s2 = format(hour_consumption);
477     
478    // s3 = "sp: " + String(spd, DEC);
479    // s3 = String(spd, DEC);
480    // s3 = String(total_ticks, DEC);
481     
482    // int iters = 3 - s3.length();
483    // int iters = 8 - s3.length();
484     
485    // for(int i = 0; i < iters; ++i)
486    //  s3 = " " + s3;
487       
488    // int iters2 = 8 - s1.length();
489     
490    // for(int i = 0; i < iters2; ++i)
491    //  s1 = " " + s1;
492    lcd.setCursor(11, 1); //+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
493    lcd.print(realv);      //++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
494    lcd.print("V"); //++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
495    //s3 += STR_KMH;
496     
497    lcd.setCursor(1,0);
498    lcd.print( show_global ? s4 : s2 );
499     
500    if (show_global_counter > SHOW_GLOBAL_PERIODS) {
501      show_global = !show_global;
502      show_global_counter = 0;
503    }
504     
505    show_global_counter++;
506     
507    lcd.setCursor(1,1);
508    lcd.print(s1);
509     
510    lcd.setCursor(0, 1);
511    lcd.write(c1);  //Заменил print ha write
512 
513    lcd.setCursor(0, 0);
514    lcd.write(c2);
515         
516    total_duration = 0;
517    total_ticks = 0;
518    t = new_t + PERIOD;
519      
520    
521 }
522}
523   
524 
525String format(unsigned int dec) {
526  if (dec > 1000) return String("##.#");
527   
528  unsigned int intPart = dec / 10;
529  unsigned int fracPart = dec % 10;
530  String result = String(intPart, DEC) + "," + String(fracPart, DEC);
531 
532  int iters = 4 - result.length();  
533  for(int i = 0; i < iters; ++i)
534    result = " " + result;
535 
536  return result;
537}

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

001#include <LiquidCrystal.h> 
002#include <OneWire.h>          
003#include <EEPROM.h>         
004byte gradus[8] = 
005{ 
006  B00110, 
007  B01001, 
008  B01001, 
009  B00110, 
010  B00000, 
011  B00000, 
012  B00000, 
013  B00000, 
014}; // создаем собственный символ "градус Цельсия" 
015byte i;                    
016byte n;                  
017byte m=0;                  
018byte t=0;                  
019int T[]={0,0,0,0};        
020int Tp[]={0,0,0,0};     
021int TD[]={0,0,0,0};
022 
023byte data[9];              
024byte TotalDS=0;             
025byte addr[4][8] = {       
026   {0,0,0,0,0,0,0,0},       
027   {0,0,0,0,0,0,0,0},
028   {0,0,0,0,0,0,0,0},
029   {0,0,0,0,0,0,0,0},
030};  
031OneWire  ds(10);            
032LiquidCrystal lcd(12, 11, 5, 4, 3, 2);  
033 
034void setup()         
035{
036  lcd.begin(16, 2);
037  
038}
039   void Menu() {           
040     lcd.clear(); 
041 
042lcd.createChar(1, gradus); // присваиваем символу "градус Целься" порядковый номер
043       lcd.setCursor(11, 0);
044        lcd.print("T1:");           
045        lcd.print(T[0]);
046        lcd.print("\1C"); //символ "градус Цельсия"            
047        i = 0;
048        n=0;
049        while (i != 1 ) 
050        {
051          if ( ds.search(addr[n]) != 1) { 
052           
053            ds.reset_search();
054            i = 1; }
055          else {        
056            n++;         
057            TotalDS = n; 
058          }
059        }
060        }
061void Gettemp() {
062 ds.reset();       
063    ds.write(0xCC,1);    
064    ds.write(0x44,1);        
065    for( n = 1; n < 90; n++) { 
066      delay(10);            
067       
068    }
069    for( n = 0; n < 4; n++) {  
070      ds.reset();               
071      ds.select(addr[n]);       
072       
073      ds.write(0xBE);          
074      for ( i = 0; i < 9; i++) {data[i] = ds.read();} 
075      Tp[n] = float((data[1] << 8) + data[0])/16.0;    
076       
077      if (Tp[n] == 85) {} else {T[n]=Tp[n];}         
078          }
079 
080byte write_DS() ;{              
081  for (i=0; i<8; i++) {        
082    if (m==0) {EEPROM.write(128+t*8+i,0);} 
083    else {EEPROM.write(128+t*8+i,addr[m-1][i]);}
084  }
085}
086 
087byte read_DS(); {              
088  for (n=0; n<4; n++) {       
089    for (i=0; i<8; i++) {      
090      addr[n][i] = EEPROM.read(128+n*8+i); 
091    }
092  }
093}
094}
095 
096void loop()  
097{
098  Menu();
099   Gettemp();
100    
101    
102}

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

Arduino.ru

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

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