Arduino.ru

Привет всем ! Нужна помощь в переделке скетча .

На экране 2004 отображается с 6 датчиков 18b20 отображается температура , как переделать скетч чтобы вывод был на экран нокиа 5110

#include "OneWire.h"// Инициализация библиотеки шины OneWire.
#include "DallasTemperature.h"// Инициализация библиотеки термодатчиков.
#include "math.h" // Библиотека математических функций
#include "stdlib.h" // Для работы со строками


// Библиотеки для работы с дисплеем
#include <LCD5110_Graph.h>
#include "Wire.h" 
#include "LiquidCrystal_I2C.h"
#include "LCD_1602_RUS.h"

// Задаем адрес и размерность дисплея. 
//LiquidCrystal_I2C lcd(0x27, 20, 4);
 LCD_1602_RUS lcd(0x27, 20, 4);


/////////////////////////////
#define ONE_WIRE_BUS1 2 // Подключение сигнального провода датчика к 2-му пину Ардуино.
OneWire oneWire1(ONE_WIRE_BUS1);// Запуск интерфейса OneWire для подключения OneWire устройств.

#define ONE_WIRE_BUS2 3 
OneWire oneWire2(ONE_WIRE_BUS2);

#define ONE_WIRE_BUS3 4 
OneWire oneWire3(ONE_WIRE_BUS3);

#define ONE_WIRE_BUS4 5 
OneWire oneWire4(ONE_WIRE_BUS4);

#define ONE_WIRE_BUS5 6 
OneWire oneWire5(ONE_WIRE_BUS5);

#define ONE_WIRE_BUS6 7 
OneWire oneWire6(ONE_WIRE_BUS6);



//////////////////////////
DallasTemperature sensor1(&oneWire1);// Указание, что устройством oneWire является термодатчик от Dallas Temperature.
DallasTemperature sensor2(&oneWire2);
DallasTemperature sensor3(&oneWire3);
DallasTemperature sensor4(&oneWire4);
DallasTemperature sensor5(&oneWire5);
DallasTemperature sensor6(&oneWire6);


// Объявление переменных
int ledPin = A0; // Аналоговый пин для подключения светодиода индикации о перегреве датчика

// Переменные означают есть ли в системе датчики, которые перегреты или дребезжат
bool err1 = true;
bool err2 = true;
bool err3 = true;
bool err4 = true;
bool err5 = true;
bool err6 = true;
bool errTmp = true; // Переменная совокупляет данные с err1-6 и означет, есть ли хотя бы 1 перегретый датчик.
 

int numberIteration = 0; // Порядковый номер итерации цикла loop
int myDelay = 0; // Задержка перед опросом следующего
int myInterval = 5; // Значение интервала градусов при котором система будет считать, что датчик не дребезжит

char noSensor[5] = " - "; // Отображение значения при отсутствующем датчике
char errSensor[5] = "***";    // Отображение значения при перегреве датчика
char hotSensor[5] = ">125";    // Отображение значения при перегреве датчика

char s1[5], s2[5], s3[5], s4[5], s5[5], s6[5]; // Переменная для хранения значения показания при выводе ("60С", "***", " - ", ">125") 

int t1, t2, t3, t4, t5, t6; // Числовой показатель температуры

// Показание датчика на предыдущем цикле и здесь же присваивается начальное значение
int tLast1 = 128;
int tLast2 = 128;
int tLast3 = 128;
int tLast4 = 128;
int tLast5 = 128;
int tLast6 = 128;


void setup(void)
{

// Инициализация светодиода
pinMode(ledPin, OUTPUT);
  
// Инициализация дисплея
lcd.init();                             // Инициализация lcd             
lcd.backlight();                        // Включаем подсветку

//////////// Запуск 6 датчиков сенсоров.
sensor1.begin(); 
sensor2.begin(); 
sensor3.begin(); 
sensor4.begin(); 
sensor5.begin(); 
sensor6.begin(); 

} 


void loop(void)
{ 
 ++numberIteration;
 
  
/////////////////////////////////////////////////////////////////////////////////////
// 1 датчик
  sensor1.requestTemperatures(); 
  t1 = roundf(sensor1.getTempCByIndex(0));
// Если нет датчика  
  if ((t1 == -127) && (t1 == tLast1))
    {
      strcpy(s1,noSensor);
      err1 = false; 
    }
  else
    {
// Если датчик перегрет  
      if (t1 == 128)
        {
          strcpy(s1,hotSensor);
          err1 = true; 
        }
      else
        {
// Если ненормальный разброс
          if (abs(tLast1-t1) >= myInterval)
            {
              strcpy(s1,errSensor);
              err1 = true;
            }
          else
            {
// Если нормальный разброс    
              if (abs(t1-tLast1) < myInterval)
                {
                  sprintf(s1, "%d", t1);
                  strcat(s1,"c");  
                  err1 = false;       
                }  
            }
        }
    }
  tLast1 = t1;

//      
  delay(myDelay);


/////////////////////////////////////////////////////////////////////////////////////  
// 2 датчик
  sensor2.requestTemperatures(); 
  t2 = roundf(sensor2.getTempCByIndex(0));
// Если нет датчика  
  if ((t2 == -127) && (t2 == tLast2))
    {
      strcpy(s2,noSensor);
      err2 = false; 
    }
  else
    {
// Если датчик перегрет  
      if (t2 == 128)
        {
          strcpy(s2,hotSensor);
          err2 = true; 
        }
      else
        {
// Если ненормальный разброс
          if (abs(tLast2-t2) >= myInterval)
            {
              strcpy(s2,errSensor);
              err2 = true;
            }
          else
            {
// Если нормальный разброс    
              if (abs(t2-tLast2) < myInterval)
                {
                  sprintf(s2, "%d", t2);
                  strcat(s2,"c");  
                  err2 = false;      
                }  
            }
        }
    }
  tLast2 = t2;

  delay(myDelay);

  
/////////////////////////////////////////////////////////////////////////////////////
// 3 датчик
  sensor3.requestTemperatures(); 
  t3 = roundf(sensor3.getTempCByIndex(0));
// Если нет датчика  
  if ((t3 == -127) && (t3 == tLast3))
    {
      strcpy(s3,noSensor);
      err3 = false; 
    }
  else
    {
// Если датчик перегрет  
      if (t3 == 128)
        {
          strcpy(s3,hotSensor); 
          err3 = true;
        }
      else
        {
// Если ненормальный разброс
          if (abs(tLast3-t3) >= myInterval)
            {
              strcpy(s3,errSensor);
              err3 = true;
            }
          else
            {
// Если нормальный разброс    
              if (abs(t3-tLast3) < myInterval)
                {
                  sprintf(s3, "%d", t3);
                  strcat(s3,"c"); 
                  err3 = false;        
                }  
            }
        }
    }
  tLast3 = t3;

  delay(myDelay);


/////////////////////////////////////////////////////////////////////////////////////
// 4 датчик
  sensor4.requestTemperatures(); 
  t4 = roundf(sensor4.getTempCByIndex(0));
// Если нет датчика  
  if ((t4 == -127) && (t4 == tLast4))
    {
      strcpy(s4,noSensor);
      err4 = false; 
    }
  else
    {
// Если датчик перегрет  
      if (t4 == 128)
        {
          strcpy(s4,hotSensor);
          err4 = true; 
        }
      else
        {
// Если ненормальный разброс
          if (abs(tLast4-t4) >= myInterval)
            {
              strcpy(s4,errSensor);
              err4 = true; 
            }
          else
            {
// Если нормальный разброс    
              if (abs(t4-tLast4) < myInterval)
                {
                  sprintf(s4, "%d", t4);
                  strcat(s4,"c");  
                  err4 = false;         
                }  
            }
        }
    }
  tLast4 = t4;

  delay(myDelay);


/////////////////////////////////////////////////////////////////////////////////////
// 5 датчик
  sensor5.requestTemperatures(); 
  t5 = roundf(sensor5.getTempCByIndex(0));
 // Если нет датчика  
  if ((t5 == -127) && (t5 == tLast5))
    {
      strcpy(s5,noSensor);
      err5 = false; 
    }
  else
    {
// Если датчик перегрет  
      if (t5 == 128)
        {
          strcpy(s5,hotSensor);
          err5 = true;  
        }
      else
        {
// Если ненормальный разброс
          if (abs(tLast5-t5) >= myInterval)
            {
              strcpy(s5,errSensor);
              err5 = true;
            }
          else
            {
// Если нормальный разброс    
              if (abs(t5-tLast5) < myInterval)
                {
                  sprintf(s5, "%d", t5);
                  strcat(s5,"c");  
                  
                  err5 = false;       
                }  
            }
        }
    }
  tLast5 = t5;

  delay(myDelay);


/////////////////////////////////////////////////////////////////////////////////////
// 6 датчик
  sensor6.requestTemperatures(); 
  t6 = roundf(sensor6.getTempCByIndex(0));
// Если нет датчика  
  if ((t6 == -127) && (t6 == tLast6))
    {
      strcpy(s6,noSensor); 
      err6 = false;
    }
  else
    {
// Если датчик перегрет  
      if (t6 == 128)
        {
          strcpy(s6,hotSensor);
          err6 = true; 
        }
      else
        {
// Если ненормальный разброс
          if (abs(tLast6-t6) >= myInterval)
            {
              strcpy(s6,errSensor);
              err6 = true;
            }
          else
            {
// Если нормальный разброс    
              if (abs(t6-tLast6) < myInterval)
                {
                  sprintf(s6, "%d", t6); 
                  strcat(s6,"c");  
                  
                  err6 = false;      
                }  
            }
        }
    }
  tLast6 = t6;

  delay(myDelay);

// Определяет, есть ли в системе хотя бы 1 датчик, который перегрет или дребезжит
if (err1 || err2 || err3 || err4 || err5 || err6)
    {
      errTmp = true;
    }
  else
    {
      errTmp = false;
    }  
    
/////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////
// Вывод информации (на экран или индикация кнопки)

// Очистка дисплея
//  lcd.clear(); 

// Зажигает светодиод если хотя бы один датчик моросит или перегрет
if (errTmp)
    {
      digitalWrite(ledPin, HIGH);
    }
  else
    {
      digitalWrite(ledPin, LOW);
    }  

// Заголовок
  if (numberIteration <= 2)// первые 3 итерации цикла выводит Status: ok!, а последующие итерации уже по состоянию
    { 
      lcd.setCursor(0, 0);                    
      lcd.print(L"Dатчики: нормально! ");       

    }
  else
    {
  if (errTmp)
     {
      lcd.setCursor(0, 0);                    
      lcd.print(L"Dатчики: внимание!  ");
      
      }       
  else
    {
      lcd.setCursor(0, 0);                    
      lcd.print(L"Dатчики: нормально! ");       
    }
            
    }  
     

/////////////////////////////////////////////////////////////////////////////////////
// 1
  lcd.setCursor(0, 1);                    
  lcd.print(L"Трм1:    ");       
  lcd.setCursor(5, 1);                                       
  lcd.print(s1);

/*
  if ((!err1) && (s1 != noSensor)){
  lcd.setCursor(5+strlen(s1), 1);
  lcd.print("c");       
  }
*/
/////////////////////////////////////////////////////////////////////////////////////
// 2
  lcd.setCursor(0, 2);                    
  lcd.print(L"Трм2:    ");       
  lcd.setCursor(5, 2);                                       
  lcd.print(s2);

/*  
  if ((!err2) && (s2 != noSensor)){
  lcd.setCursor(5+strlen(s2), 2);
  lcd.print("c");       
  }
*/  

/////////////////////////////////////////////////////////////////////////////////////
// 3
  lcd.setCursor(0, 3);                    
  lcd.print(L"Трм3:    ");       
  lcd.setCursor(5, 3);                                       
  lcd.print(s3);



/////////////////////////////////////////////////////////////////////////////////////
/// 2 столбец
// 4
  lcd.setCursor(10, 1);                    
  lcd.print(L"Трм4:    ");       
  lcd.setCursor(15, 1);                                       
  lcd.print(s4);

  
  
/////////////////////////////////////////////////////////////////////////////////////
// 5 
  lcd.setCursor(10, 2);                    
  lcd.print(L"Трм5:    ");       
  lcd.setCursor(15, 2);                                       
  lcd.print(s5);

  
/////////////////////////////////////////////////////////////////////////////////////
// 6 
  lcd.setCursor(10, 3);                    
  lcd.print(L"Трм6:    ");
  lcd.setCursor(15, 3);                                       
  lcd.print(s6);    



}