Здравствуйте помогите пожалуйста с программным кодом,не запускается программа по приходу смс,в консоли выволит номер тел,сообщение on и на этом все.Программный код
введите или вставьте сюда код
```//============НАСТРОЙКИ СИМ800==============
String START = "on"; //текст выключения
String STOP = "off"; //текст выключения
#define RX 2
#define TX 3
String phones = "+79528860989"; // Белый список телефонов
#include <SoftwareSerial.h> // Библиотека програмной реализации обмена по UART-протоколу
SoftwareSerial SIM800(RX, TX); // RX, TX
int STATUS = 0; //0 - нет смс, 1 - он, 2 - офф
String _response = ""; // Переменная для хранения ответа модуля
long lastUpdate = millis(); // Время последнего обновления
long updatePeriod = 60000; // Проверять каждую минуту
bool hasmsg = false; // Флаг наличия сообщений к удалению
//проверка непрочитанных
void scan_sms() {
do {
_response = sendATCommand("AT+CMGL=\"REC UNREAD\",1", true); // Отправляем запрос чтения непрочитанных сообщений
if (_response.indexOf("+CMGL: ") > -1) { // Если есть хоть одно, получаем его индекс
int msgIndex = _response.substring(_response.indexOf("+CMGL: ") + 7, _response.indexOf("\"REC UNREAD\"", _response.indexOf("+CMGL: ")) - 1).toInt();
char iii = 0; // Объявляем счетчик попыток
do {
iii++; // Увеличиваем счетчик
_response = sendATCommand("AT+CMGR=" + (String)msgIndex + ",1", true); // Пробуем получить текст SMS по индексу
_response.trim(); // Убираем пробелы в начале/конце
if (_response.endsWith("OK")) { // Если ответ заканчивается на "ОК"
if (!hasmsg) hasmsg = true; // Ставим флаг наличия сообщений для удаления
sendATCommand("AT+CMGR=" + (String)msgIndex, true); // Делаем сообщение прочитанным
sendATCommand("\n", true); // Перестраховка - вывод новой строки
parseSMS(_response); // Отправляем текст сообщения на обработку
break; // Выход из do{}
} else { // Если сообщение не заканчивается на OK
Serial.println("Error answer"); // Какая-то ошибка
sendATCommand("\n", true); // Отправляем новую строку и повторяем попытку
}
} while (iii < 10);
break;
} else {
lastUpdate = millis(); // Обнуляем таймер
if (hasmsg) {
sendATCommand("AT+CMGDA=\"DEL READ\"", true); // Удаляем все прочитанные сообщения
hasmsg = false;
}
break;
}
} while (1);
}
String sendATCommand(String cmd, bool waiting) {
String _resp = ""; // Переменная для хранения результата
Serial.println(cmd); // Дублируем команду в монитор порта
SIM800.println(cmd); // Отправляем команду модулю
if (waiting) { // Если необходимо дождаться ответа...
_resp = waitResponse(); // ... ждем, когда будет передан ответ
// Если Echo Mode выключен (ATE0), то эти 3 строки можно закомментировать
if (_resp.startsWith(cmd)) { // Убираем из ответа дублирующуюся команду
_resp = _resp.substring(_resp.indexOf("\r", cmd.length()) + 2);
}
Serial.println(_resp); // Дублируем ответ в монитор порта
}
return _resp; // Возвращаем результат. Пусто, если проблема
}
String waitResponse() { // Функция ожидания ответа и возврата полученного результата
String _resp = ""; // Переменная для хранения результата
long _timeout = millis() + 10000; // Переменная для отслеживания таймаута (10 секунд)
while (!SIM800.available() && millis() < _timeout) {}; // Ждем ответа 10 секунд, если пришел ответ или наступил таймаут, то...
if (SIM800.available()) { // Если есть, что считывать...
_resp = SIM800.readString(); // ... считываем и запоминаем
} else { // Если пришел таймаут, то...
Serial.println("Timeout..."); // ... оповещаем об этом и...
}
return _resp; // ... возвращаем результат. Пусто, если проблема
}
void parseSMS(String msg) { // Парсим SMS
String msgheader = "";
String msgbody = "";
String msgphone = "";
msg = msg.substring(msg.indexOf("+CMGR: "));
msgheader = msg.substring(0, msg.indexOf("\r")); // Выдергиваем телефон
msgbody = msg.substring(msgheader.length() + 2);
msgbody = msgbody.substring(0, msgbody.lastIndexOf("OK")); // Выдергиваем текст SMS
msgbody.trim();
int firstIndex = msgheader.indexOf("\",\"") + 3;
int secondIndex = msgheader.indexOf("\",\"", firstIndex);
msgphone = msgheader.substring(firstIndex, secondIndex);
Serial.println("Phone: " + msgphone); // Выводим номер телефона
Serial.println("Message: " + msgbody); // Выводим текст SMS
if (msgphone.length() > 6 && phones.indexOf(msgphone) > -1) { // Если телефон в белом списке, то...
msgbody.toUpperCase();//делаем большими буквами
START.toUpperCase();
STOP.toUpperCase();
//проверяем это смс от нужного ли номера?
if (msgbody == START) {
//digitalWrite(13, 1);
Serial.println("START");
STATUS = 1;
} else if (msgbody == STOP) {
//digitalWrite(13, 0);
Serial.println("STOP");
STATUS = 2;
}
} else {
Serial.println("Unknown phonenumber");
}
}
void sendSMS(String phone, String message) {
sendATCommand("AT+CMGS=\"" + phone + "\"", true); // Переходим в режим ввода текстового сообщения
sendATCommand(message + "\r\n" + (String)((char)26), true); // После текста отправляем перенос строки и Ctrl+Z
}
//==========================================
#include <OneWire.h>
#include <LiquidCrystal_I2C.h>
#include "pitches.h"
#include <EEPROM.h> // импортируем библиотеку
/////////////////////////////////////////////////////////////////////////////////////////////////////
unsigned long znach_EEPROM;
////////////////////////////////////////////////////////////////////////////////////////////////////
OneWire ds(8); // Объект OneWire
int temperature = 0; // Глобальная переменная для хранения значение температуры с датчика DS18B20
long lastUpdateTime = 0; // Переменная для хранения времени последнего считывания с датчика
const int TEMP_UPDATE_TIME = 1000; // Определяем периодичность проверок
LiquidCrystal_I2C lcd(0x27,16,2);
//////////////////////////////////////////////////////////////////////////////////////////////////////
const int PIN_MOTOR = 9;
#define RELE_1 5// Выход на 3 реле 7 пин, "Питание"
#define RELE_2 6 // Выход на 1реле 11 пин, "Клапан"
#define RELE_3 7 // Выход на 2 реле 8 пин, "Свеча"
#define speakerPin 4 // Спикер, он же buzzer, он же beeper
#define Ypr A0 // Вход управления на A3 пин
#define Dn A1 // Вход датчика нагрева на A1 пин
#define Dp A2 // Вход датчика перегрева на A2 пин
#define TEMP_MINUS A3//НАСТРОЙКА ТЕМП МИНУС
#define TEMP_PLUS 13//НАСТРОЙКА ТЕМП ПЛЮС
#define ON 0
#define OFF 1
#define ON_1 1
#define OFF_1 0
//////////////////////////////////////////////////////////////////////////////////////////////
//
#define a 2 // Время включения клапана при старте, сек.
#define b 6 // Время включения свечи при старте, сек.
#define c 15 // Время включения оборотов MIN при старте, сек.
#define d 60 // Время выключения свечи при старте, сек.
//#define e 30 // Время включения оборотов MAX при старте, сек.
#define f 240 // Длительность цикла запуска при старте, сек
#define g 180 // Время продувки печки при остановке, сек.
#define i 185 // Длительность цикла остановки
#define j 180 // Время остановки двигателя ALARM, сек.
#define k 65 // Время отключения питания ALARM, сек.
#define l 190 // Длительность цикла ALARM, сек.
#define m 60 // Время остановки двигателя NO FUEL, сек.
#define n 35 // Время отключения 12v NO FUEL, сек.
#define o 80 // Длительность цикла NO FUEL, сек.
#define h 25 // Время отключения 12v при остановке, сек.
//////////////////////////////////////////////////////////////////////////////////////////////////////////
//
int R=OFF; // Вводим переменную для хранения режима работы и присваиваем ей выключенное состояние
int A=OFF; // Вводим переменную для хранения аварийного состояния и присваеваем ей выключенное состояние
int O; // Вводим переменную состояния оборотов
int flag=0;
int scht = 0;
int e;
int set=0;
int U=OFF; // Вводим переменную состояния блока питания 12v
///////////////////////////////////////////////////////////////////////////////////////////////////////////
unsigned char mx=0;
unsigned char sr=0;
unsigned char mn=0;
unsigned char zp=0;
///////////////////////////////////////////////////////
void setup(){
////////////////////////////////////////////////////////////////////////////
Serial.begin(9600); // Скорость обмена данными с компьютером
SIM800.begin(9600); // Скорость обмена данными с модемом
Serial.println("Start!");
sendATCommand("AT", true); // Отправили AT для настройки скорости обмена данными
//sendATCommand("AT+CMGDA=\"DEL ALL\"", true); // Удаляем все SMS, чтобы не забивать память
// Команды настройки модема при каждом запуске
//_response = sendATCommand("AT+CLIP=1", true); // Включаем АОН
//_response = sendATCommand("AT+DDET=1", true); // Включаем DTMF
sendATCommand("AT+CMGF=1;&W", true); // Включаем текстовый режима SMS (Text mode) и сразу сохраняем значение (AT&W)!
lastUpdate = millis(); // Обнуляем таймер
////////////////////////////////////////////////////////////////////////////
// Устанавливаем высокий уровень
pinMode(PIN_MOTOR, OUTPUT);
pinMode(RELE_1, OUTPUT); // Настраиваем пин как выход
pinMode(RELE_2, OUTPUT); // Настраиваем пин как выход
pinMode(RELE_3, OUTPUT); // Настраиваем пин как выход
pinMode(Ypr, INPUT); // Настраиваем пин Ypr как вход
digitalWrite(Ypr, HIGH); // включить подтягивающий резистор
pinMode(Dn, INPUT); // Настраиваем пин Dn как вход
digitalWrite(Dn, HIGH); // включить подтягивающий резистор
pinMode(Dp, INPUT); // Настраиваем пин Dp как вход
digitalWrite(Dp, HIGH); // включить подтягивающий резистор
pinMode(TEMP_PLUS, INPUT); // Настраиваем пин TEMP_PLUS как вход
digitalWrite(TEMP_PLUS, HIGH); // включить подтягивающий резистор
pinMode(TEMP_MINUS, INPUT); // Настраиваем пин TEMP_PLUS как вход
digitalWrite(TEMP_MINUS, HIGH); // включить подтягивающий резистор
set= EEPROM.read(znach_EEPROM); //ЧТЕНИЕ ЗНАЧЕНИЯ ИЗ ЕЕПРОМ
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//
digitalWrite(RELE_1, OFF_1); // Устанавливаем реле в выключенное состояние
digitalWrite(RELE_2, OFF_1); // Устанавливаем реле в выключенное состояние
digitalWrite(RELE_3, OFF_1); // Устанавливаем реле в выключенное состояние
////////////////////////////////////////////////////////////////////////////
lcd.init(); // Инициируем дисплей
lcd.backlight(); // Включаем подсветку
////////////////////////////////////////////////////////////////////////////
//Выведем на дисплей стартовое сообщение на 2 секунды
lcd.setCursor(0, 0);
lcd.print(" TEMP.CONTROLLER ");
lcd.setCursor(0, 1);
lcd.print(" OV-95 V1.0 ");
delay(2000);
/*
// звук "Успешное включение"
tone(speakerPin, NOTE_A7); delay(150);
tone(speakerPin, NOTE_G7); delay(150);
tone(speakerPin, NOTE_E7); delay(150);
tone(speakerPin, NOTE_C7); delay(150);
tone(speakerPin, NOTE_D7); delay(150);
tone(speakerPin, NOTE_B7); delay(150);
tone(speakerPin, NOTE_F7); delay(150);
tone(speakerPin, NOTE_C7); delay(150);
noTone(speakerPin);
delay(2000);
*/
//Очистим дисплей
lcd.clear();
lcd.setCursor(0, 0); // Устанавливаем курсор
lcd.print("Mode:"); // Выводим на дисплей "Mode:"
lcd.setCursor(5, 0); // Устанавливаем курсор
lcd.print("OFF"); // Выводим на дисплей "OFF"
}
void loop(){
//////////////////////////////////////////////////
if (lastUpdate + updatePeriod < millis()) { // Пора проверить наличие новых сообщений
scan_sms();
}
if (SIM800.available()) { // Если модем, что-то отправил...
_response = waitResponse(); // Получаем ответ от модема для анализа
_response.trim(); // Убираем лишние пробелы в начале и конце
Serial.println(_response); // Если нужно выводим в монитор порта
if (_response.indexOf("+CMTI:") > -1) { // Пришло сообщение об отправке SMS
lastUpdate = millis() - updatePeriod; // Теперь нет необходимости обрабатываеть SMS здесь, достаточно просто
// сбросить счетчик автопроверки и в следующем цикле все будет обработано
}
}
if (Serial.available()) { // Ожидаем команды по Serial...
SIM800.write(Serial.read()); // ...и отправляем полученную команду модему
};
/////////////////////////////////////////////////////////
detectTemperature() ; // Определяем температуру от датчика DS18b20
// Т.к. переменная temperature имеет тип int, дробная часть будет просто отбрасываться
// Начало процедуры отображения температуры
lcd.setCursor(0, 1); // Индикация Т1
lcd.print("T1=");
lcd.print(temperature);
lcd.print("C ");
/////////////////////////////////////////////////////////////////////////////////////
// Начало процедуры отображения ЗАДАННОЙ ТЕМП
lcd.setCursor(7, 1); // Индикация Т1
lcd.print("ZT=");
lcd.print(set);
lcd.print("C ");
// Конец процедуры отображения температуры
//************************************************************************************
//************************************************************************************
// Начало процедуры запуска
if(digitalRead(Ypr)==ON && flag == 1)
{
flag = 0; // чтобы мы много раз не нажимали кнопку, а только 1 раз
scht ++; // прибавляем по одному для увели-я яркости
delay(100);
if (scht>2) {scht = 1;} // чтобы scht не был больше значения 4
}
if(digitalRead(Ypr)==OFF ){;flag = 1; }
////////////////////////////////////////////////////////////////////////////////////////
//ПРОЦЕДУРА НАСТРОЙКИ ЗАДАННОЙ ТЕМПЕРАТУРЫ
if(digitalRead(TEMP_PLUS)==ON )
{
////////////////////////////////////////////////////////////
set++;// прибавляем по одному для увели-я яркости
delay(200);
if (set>30) {set = 30;} // чтобы scht не был больше значения 4
EEPROM.write(0, znach_EEPROM=set );//ЗАПИСЬ ЗНАЧЕНИЯ В ЕЕПРОМ
}
if(digitalRead(TEMP_MINUS)==ON)
{
//ЗВУК СОПРОВОЖДЕНИЕ КНОПОК
set--;// прибавляем по одному для увели-я яркости
delay(200);
if (set<1) {set = 0;} // чтобы scht не был больше значения 4
EEPROM.write(0, znach_EEPROM=set );//ЗАПИСЬ ЗНАЧЕНИЯ В ЕЕПРОМ
}
//КОНЕЦ ПРОЦЕДУРЫ НАСТРОЙКИ ЗАДАННОЙ ТЕМПЕРАТУРЫ
///////////////////////////////////////////////////////////////////////////////////
//НАЧАЛО ПРОЦЕДУРЫ ЗАПУСКА ОТОПИТЕЛЯ
/////////////////////////////////////////////////////////////////////////////
if((scht == 1&&R==OFF&&A==OFF) || STATUS == 1) // Проверяем условия запуска
{
STATUS = 0;
lcd.setCursor(5, 0); // Устанавливаем курсор
lcd.print("ON "); // Выводим на дисплей "ON"
// звук ОК
for (int z=400; z<6000; z=z*1.5) { tone(speakerPin, z); delay(20); }
noTone(speakerPin);
delay(1000);
for(int x=0; x<f; x++) // Запускаем таймер, каждый цикл + 1 секунда
{
digitalWrite(RELE_1, ON_1); // Включаем блок питания
lcd.setCursor(14,1); // Индикация включения 12v
lcd.print("BP"); // Выводим на дисплей символ батарейки
if (x==a) // Если x= а секунд, то
{
digitalWrite(RELE_2, ON_1); // Включаем клапан на а секунде
lcd.setCursor(8, 0); // Устанавливаем курсор
lcd.print("K"); // Выводим на дисплей значек включения клапана
}
if (x==3) // Если x= b секунд, то
{
digitalWrite(RELE_3, ON_1); // Включаем свечу на b секунде
lcd.setCursor(10, 0); // Устанавливаем курсор
lcd.print("S"); // Выводим на дисплей значек включения свечи
}
if (x==c) //Если x= c секунд, то
{
//ВКЛЮЧАЕМ СРЕДНИЕ ОБОРОТЫ
lcd.setCursor(12, 0); // Устанавливаем курсор
lcd.print("SRED"); // Выводим на дисплей индикацию MIN оборотов
delay(1000);
while(e<170)
{
e=e+1;
analogWrite(PIN_MOTOR, e);
delay(20); // ставим задержку для эффекта
}
}
if (x==d) //Если x= d секунд, то
{
digitalWrite(RELE_3, OFF_1); // Выключаем свечу на 25 секунде
lcd.setCursor(10, 0); // Устанавливаем курсор
lcd.print(" "); // Гасим на дисплее значек свечи
}
delay (1000); // Ждем 1 секунду
// Начало процедуры отображения ЗАДАННОЙ ТЕМП
lcd.setCursor(7, 1); // Индикация Т1
lcd.print("ZT=");
// Начало процедуры отображения температуры
lcd.setCursor(0, 1); // Индикация Т1
lcd.print("T1=");
lcd.print(temperature);
lcd.print("C");
}
R=ON; // Запоминаем что печка запущена
}
// Конец процедуры запуска
//**************************************************************************************
//**************************************************************************************
// Процедура опроса температуры смены оборотов
if(temperature<=(set-2)&&R==ON&mx==0) // Проверяем условия смены оборотов
{
lcd.setCursor(12, 0); // Устанавливаем курсор
lcd.print("MAX "); // Выводим на дисплей индикацию МАКС оборотов
// Начало процедуры отображения температуры
lcd.setCursor(0, 1); // Индикация Т1
lcd.print("T1=");
lcd.print(temperature);
lcd.print("C ");
delay(1000);
while(e<255)
{
//ВКЛЮЧАЕМ МАКСИМАЛЬНЫЕ ОБОРОТЫ
e=e+1;
analogWrite(PIN_MOTOR, e);
delay(20); // ставим задержку для эффекта
}
mx=1;
sr=0;
mn=0;
zp=0;
}
if(temperature==set&&R==ON&sr==0) // Проверяем условия смены оборотов
{
//ВКЛЮЧАЕМ СРЕДНИЕ ОБОРОТЫ
lcd.setCursor(12, 0); // Устанавливаем курсор
lcd.print("SRED"); // Выводим на дисплей индикацию MIN оборотов
// Начало процедуры отображения температуры
lcd.setCursor(0, 1); // Индикация Т1
lcd.print("T1=");
lcd.print(temperature);
lcd.print("C ");
delay(1000);
while(!(e==170))
{
if (e > 170)
{
e = e -1;
analogWrite(PIN_MOTOR, e);
delay(20);
}
else
{
e=e+ 1;
analogWrite(PIN_MOTOR, e);
delay(20);
}
}
mx=0;
sr=1;
mn=0;
zp=0;
}
if(temperature>=(set+2)&&R==ON&&mn==0) // Проверяем условия смены оборотов
{
lcd.setCursor(12, 0); // Устанавливаем курсор
lcd.print("MIN "); // Выводим на дисплей индикацию MIN оборотов
// Начало процедуры отображения температуры
lcd.setCursor(0, 1); // Индикация Т1
lcd.print("T1=");
lcd.print(temperature);
lcd.print("C ");
delay(1000);
while(e>120)
{
e=e-1;
analogWrite(PIN_MOTOR, e);
delay(20);
}
mx=0;
sr=0;
mn=1;
zp=0;
}
//***********************************************************************************
// Конец процедуры смены оборотов
//**************************************************************************************
//**************************************************************************************
// Начало процедуры остановки
if((scht == 2&&R==ON&&A==OFF) || STATUS==2) // Проверяем условия остановки
{
STATUS = 0;
// звук ОК
for (int z=400; z<6000; z=z*1.5) { tone(speakerPin, z); delay(20); }
noTone(speakerPin);
delay(1000);
///////////////////////////////////////////////////////////////////////////////////////////////////
lcd.setCursor(5, 0); // Устанавливаем курсор
lcd.print("OFF"); // Выводим на дисплей OFF вместо ON
digitalWrite(RELE_2, OFF_1); // Отключаем клапан
lcd.setCursor(8, 0); // Устанавливаем курсор
lcd.print(" "); // Гасим индикацию клапана
lcd.setCursor(12, 0); // Устанавливаем курсор
lcd.print("MAX "); // Выводим на дисплей индикацию МАКС оборотов
while(e<255)
{
//ВКЛЮЧАЕМ МАКСИМАЛЬНЫЕ ОБОРОТЫ
e=e+1;
analogWrite(PIN_MOTOR, e);
delay(20); // ставим задержку для эффекта
}
for(int x=0; x<i; x++) // Запускаем таймер, каждый цикл + 1 секунда
{
if (x==g) //Если x= g секунд, то
{
//ВЫКЛЮЧАЕМ ОБОРОТЫ
while(e>0)
{
e=e-1;
analogWrite(PIN_MOTOR, e);
delay(20); // ставим задержку для эффекта
lcd.setCursor(12, 0); // Устанавливаем курсор
lcd.print(" "); // Гасим индикацию оборотов
}
}
if (x==h)// Если x= h секунд, то
{
digitalWrite(RELE_1, OFF_1); // Отключаем блок питания на 15 секунде
lcd.setCursor(14,1); // Устанавливаем курсор
lcd.print(" "); // Гасим значек батарейки
}
delay (1000); // Ждем 1 секунду
}
R=OFF; // Обозначаем что печка выключилась
}
// Конец процедуры остановки
//************************************************************************************
//************************************************************************************
// Начало процедуры аварийной остановки
if(digitalRead(Dp)==OFF&&R==ON) // Проверяем аварийный датчик перегрева
{
/*
// звук "ERROR"
for (int y=0; y <3; y++){
for (int z=1000; z<2000; z=z*1.1) { tone(speakerPin, z); delay(10); }
delay(50);
for (int z=1000; z>500; z=z*1.9) { tone(speakerPin, z); delay(10); }
delay(50);
}
*/
delay(1000);
////////////////////////////////////////////////////////////////////////////////////////////////////////
//ПЕРЕКЛЮЧАЕМ В МАКСИМАЛЬНЫЕ ОБОРОТЫ
lcd.setCursor(12, 0); // Устанавливаем курсор
lcd.print("MAX "); // Выводим на дисплей индикацию MAX оборотов
digitalWrite(RELE_2, OFF_1); // Отключаем клапан
lcd.setCursor(9, 0); // Устанавливаем курсор
lcd.print(" "); // Гасим индикацию клапана
lcd.setCursor(5, 0); // Устанавливаем курсор
lcd.print("ALARM"); // Выводим на дисплей индикацию "ALARM"
while(e<255)
{
//ВКЛЮЧАЕМ ВЫСОКИЕ ОБОРОТЫ
e=e+1;
analogWrite(PIN_MOTOR, e);
delay(20); // ставим задержку для эффекта
}
//////////////////////////////////////////////////////////////////////////////////////////////////////////
for(int x=0; x<l; x++) // Запускаем таймер, каждый цикл + 1 секунда
{
if (x==j) //Если x= j секунд, то
{
lcd.setCursor(12, 0); // Устанавливаем курсор
lcd.print(" "); // Гасим индикацию оборотов
//ВЫКЛЮЧАЕМ ОБОРОТЫ
while(e>0)
{
e=e-1;
analogWrite(PIN_MOTOR, e);
delay(20); // ставим задержку для эффекта
}
}
if (x==k)// Если x= h секунд, то
{
digitalWrite(RELE_1, OFF_1); // Отключаем блок питания на 15 секунде
lcd.setCursor(14,1); // Устанавливаем курсор
lcd.print(" "); // Гасим значек батарейки
}
delay (1000); // Ждем 1 секунду
}
lcd.setCursor(0, 0); // Индикация режима ALARM
lcd.print(" ALARM! ");
R=OFF;
A=ON; // Ошибка из за перегрева
}
// Конец процедуры аварийной остановки
//***************************************************************************************
//*************************************************************************************
// Начало процедуры отключения при погасании
if(digitalRead(Dn)==ON&&R==ON&&A==OFF) // Проверяем условия отключения при погасании
{
/*
// звук "ERROR"
for (int y=0; y <3; y++){
for (int z=1000; z<2000; z=z*1.1) { tone(speakerPin, z); delay(10); }
delay(50);
for (int z=1000; z>500; z=z*1.9) { tone(speakerPin, z); delay(10); }
delay(50);
}
*/
digitalWrite(RELE_2, OFF_1); // Отключаем клапан
lcd.setCursor(12, 0); // Устанавливаем курсор
lcd.print("MAX "); // Выводим на дисплей индикацию оборотов MAX
lcd.setCursor(9, 0); // Устанавливаем курсор
lcd.print(" "); // Гасим индикацию клапана
lcd.setCursor(5, 0); // Устанавливаем курсор
lcd.print("FUEL"); // Выводим на дисплей индикацию "FUEL"
while(e<255)
{
//ВКЛЮЧАЕМ ВЫСОКИЕ ОБОРОТЫ
e=e+1;
analogWrite(PIN_MOTOR, e);
delay(20); // ставим задержку для эффекта
}
for(int x=0; x<o; x++) // Запускаем таймер
{
if (x==m) //Если x= m секунд, то
{
lcd.setCursor(12, 0); // Устанавливаем курсор
lcd.print(" "); // Гасим индикацию оборотов
//ВЫКЛЮЧАЕМ ОБОРОТЫ
while(e>0)
{
e=e-1;
analogWrite(PIN_MOTOR, e);
delay(20); // ставим задержку для эффекта
}
}
if (x==n)// Если x= h секунд, то
{
digitalWrite(RELE_1, OFF_1); // Отключаем блок питания на 15 секунде
lcd.setCursor(14,1); // Устанавливаем курсор
lcd.print(" "); // Гасим значек батарейки
}
delay (1000); // Ждем 1 секунду
// Начало процедуры отображения ЗАДАННОЙ ТЕМП
lcd.setCursor(7, 1); // Индикация Т1
lcd.print("ZT=");
// Начало процедуры отображения температуры
lcd.setCursor(0, 1); // Индикация Т1
lcd.print("T1=");
lcd.print(temperature);
lcd.print("C ");
// Конец процедуры отображения температуры
}
R=OFF;
A=ON;
}
}
// Конец процедуры отключения при погасании
//*************************************************************************************************************************
//*****************************************************************************************************************************
int detectTemperature(){
byte data[2];
ds.reset();
ds.write(0xCC);
ds.write(0x44);
if (millis() - lastUpdateTime > TEMP_UPDATE_TIME)
{
lastUpdateTime = millis();
ds.reset();
ds.write(0xCC);
ds.write(0xBE);
data[0] = ds.read();
data[1] = ds.read();
// Формируем значение
temperature = (data[1] << 8) + data[0]; temperature = temperature >> 4;
}
}
````Программный код`