Код

1.1

const int LED = 10; // вивід для підключення світлодіода 10 (D10)
void setup ()
{
// Конфігуріруем вивід підключення світлодіода як вихід (OUTPUT)
pinMode (LED, OUTPUT);
}
void loop ()
{
// включаємо світлодіод, подаючи на вивід 1 (HIGH)
digitalWrite (LED, HIGH);
// пауза 1 сек (1000 мс)
delay (1000);
// вимикаємо світлодіод, подаючи на вивід 0 (LOW)
digitalWrite (LED, LOW);
// пауза 1 сек (1000 мс)
delay (1000);
}

2.1

2.2

2.3

const int LED = 10; // Контакт 10 для підключення світлодіода
const int BUTTON = 2; // Контакт 2 для підключення кнопки
int tekButton = LOW; // Змінна для збереження поточного стану кнопки
int prevButton = LOW; // Змінна для збереження попереднього стану
// до нопкі
boolean ledOn = false; // Поточний стан світлодіода (ввімкнутий/вимкнений)
void setup ()
{
// Конфігурувати контакт світлодіода як вихід
pinMode (LED, OUTPUT);
// Конфігурувати контакт кнопки як вхід
pinMode (BUTTON, INPUT);
}
// Функція згладжування брязкоту. Приймає в якості
// аргументу попередній стан кнопки і видає фактичне.
boolean debounce (boolean last)
{
boolean current = digitalRead (BUTTON); // Вважати стан кнопки,
if (last! = current) // якщо змінилося ...
{
delay (5); // ж дем 5 м з
current = digitalRead (BUTTON); // зчитуємо стан кнопки
return current; // повертаємо стан кнопки
}
}
void loop ()
{
tekButton = debounce (prevButton);
if (prevButton == LOW && tekButton == HIGH) // якщо натискання ...
{
ledOn =! ledOn; // інвертувати значення стану світлодіода
}
prevButton = tekButton;
digitalWrite (LED, ledOn); // змінити статус стану світлодіода
}

3.1

const int LED = 10;// вивід для підключення світлодіода 10 (D10)
void setup ()
{
// Конфігуріруем вивід підключення світлодіода як вихід (OUTPUT)
pinMode (10, OUTPUT);
// включаємо світлодіод, подаючи на вивід 1 (HIGH)
digitalWrite (LED, HIGH );
}
void loop ()
{;}

4.1

const int POT = 0; // Аналоговий вхід A0 для підключення потенціометра
int valpot = 0; // змінна для зберігання значення потенціометра
void setup ()
{
Serial.begin (9600);
}
void loop ()
{
valpot = analogRead (POT); // читання даних потенциометра
Serial.println (valpot); // вивід значень в послідовний порт
delay (500); // затримка 0.5 сек
}

4.2

const int POT = 0; // Аналоговий вхід A0 для підключення потенціометра
int valpot = 0; // змінна для зберігання значення потенціометра
// список контактів підключення світлодіодної шкали
const int pinsled [10] = {3,4,5,6,7,8,9,10,11,12};
int countleds = 0; // змінна для зберігання значення шкали
void setup ()
{
for (int i = 0; i <10; i ++)
{
// Конфігурувати контакти приєднання шкали як виходи
pinMode (pinsled [i], OUTPUT);
digitalWrite (pinsled [i], LOW);
{
}
void loop ()
{
valpot = analogRead (POT); // читання даних потенциометра
// масштабується значення до інтервалу 0-10
countled = map (valpot, 0,1023,0,10);
// запалюємо кількість смужок на шкалі, рівне countled
for (int i = 0; i <10; i ++)
{
if (i digitalWrite (pinsled [i], HIGH);
else // гасимо світлодіод шкали
digitalWrite (pinsled [i], LOW);
}
}

5.1

const int RED = 11; // вивід червоною ноги RGB-світлодіода
const int GREEN = 10; // вивід зеленої ноги RGB-світлодіода
const int BLUE = 9; // вивід синьою ноги RGB-світлодіода
int red; // змінна для зберігання R-складової кольору
int green; // змінна для зберігання G-складової кольору
int blue; // змінна для зберігання B-складової кольору
void setup ()
{;}
void loop ()
{
// від червоного до жовтого
red = 255; green = 0; blue = 0;
for (green = 0; green <= 255; green ++)
setRGB (red, green, blue);
// від жовтого до зеленого
for (red = 255; red> = 0; red -)
setRGB (red, green, blue);
// від зеленого до блакитного
for (blue = 0; blue <= 255; blue ++)
setRGB (red, green, blue);
// від блакитного до синього
for (green = 255; green> = 0; green -)
setRGB (red, green, blue);
// від синього до фіолетового
for (red = 0; red <= 255; red ++)
setRGB (red, green, blue); delay (2000);
}
// функція установки кольору RGB-світлодіода
void setRGB (int r, int g, int b)
{
analogWrite (RED , r);
analogWrite (GREEN, g);
analogWrite (BLUE, b);
delay (10);
}

6.1

// список виводів Arduino для підключення до розрядів ag
// семисегментний індикатор
int pins [7] = {2,3,4,5,6,7,8};
// значення для виведення цифр 0-9
byte numbers [10] = {B11111100, B01100000, B11011010, B11110010, B01100110,
B10110110, B10111110, B11100000, B11111110, B11100110};
// змінна для зберігання значення поточної цифри
int number = 0;
void setup ()
{
// Конфігурувати контакти як виходи
for (int i = 0; i <7; i ++)
pinMode (pins [i], OUTPUT);
}
void loop ()
{
showNumber (number);
delay (1000);
number = (number + 1)% 10;
}
// функція виведення цифри на семисегментний індикатор
void showNumber (int num)
{
for (int i = 0; i <7; i ++)
{
if (bitRead (numbers [num], 7-i) == HIGH) // запалити сегмент
digitalWrite (pins [i], HIGH);
else // загасити сегмент
digitalWrite (pins [i], LOW);
}
}

7.1

7.2

// список виводів Arduino для підключення до розрядів ag
// семисегментний індикатор
int pins [8] = {9,13,4,6,7,10,3,5};
// значення для виведення цифр 0-9
byte numbers [10] = {B11111100, B01100000, B11011010,
B11110010, B01100110, B10110110,
B10111110, B11100000, B11111110,
B11110110};
// змінна для зберігання і обробки поточного значення
int number = 0;
int number1 = 0;
int number2 = 0;
// семисегментний індикатор
int pindigits [4] = {2,8,11,12};
// змінна для зберігання поточного розряду
int digit = 0;
// для відмірювання 100 мс
unsigned long millis1 = 0;
// режим 1 - секундомір працює
mode = 0;
const int BUTTON = 14; // Контакт 14 (A0) для підключення кнопки
int tekButton = LOW; // Змінна для збереження поточного стану кнопки
int prevButton = LOW; // Змінна для збереження попереднього стану
// до нопкі
boolean ledOn = false; // Поточний стан світлодіода (ввімкнутий/вимкнений)
void setup ()
{
// Конфігурувати контакт кнопки як вхід
pinMode (BUTTON, INPUT);
// Конфігурувати контакти як виходи
for (int i = 0; i <8; i ++)
pinMode (pins [i], OUTPUT);
for (int i = 0; i <4; i ++)
{PinMode (pindigits [i], OUTPUT);
digitalWrite (pindigits [i], HIGH);
}
}
void loop ()
{
tekButton = debounce (prevButton);
if (prevButton == LOW && tekButton == HIGH) // якщо натискання ...
{
mode = 1-mode; // зміна режиму
if (mode == 1)
number = 0;
}
if (millis () - millis1> = 100 && mode == 1)
{Millis1 = millis1 + 100;
number = number + 1;
if (number == 10000)
number = 0;
}
number1 = number;
for (int i = 0; i <4; i ++)
{
number2 = number1% 10;
number1 = number1 / 10;
showNumber (number2, i);
for (int j = 0; j <4; j ++)
digitalWrite (pindigits [j], HIGH);
digitalWrite (pindigits [i], LOW);
delay (1);
}
}
// функція виведення цифри на семисегментний індикатор
void showNumber (int num, int dig)
{
for (int i = 0; i <8; i ++)
{
if (bitRead (numbers [num], 7-i) == HIGH) // запалити сегмент
digitalWrite (pins [i], HIGH);
else // загасити сегмент
digitalWrite (pins [i], LOW);
}
if (dig == 1) // десяткова точка для другого розряду
digitalWrite (pins [7], HIGH);
}
// Функція згладжування брязкоту. Приймає в якості
// аргументу попередній стан кнопки і видає фактичне.
boolean debounce (boolean last)
{
boolean current = digitalRead (BUTTON); // Вважати стан кнопки,
if (last! = current) // якщо змінилося ...
{
d elay (5); // ж дем 5 м з
current = digitalRead (BUTTON); // зчитуємо стан кнопки
return current; // повертаємо стан кнопки
}
}

8.1

// Підключення бібліотеки SPI
#include <SPI.h>
// пін SS
int pin_spi_ss = 8;
// значення для виведення цифр 0-9
byte numbers [10] = {B11111100, B01100000, B11011010,
B11110010, B01100110, B10110110, B10111110, B11100000, B11111110, B11110110};
// змінна для зберігання значення поточної цифри
int number = 0;
int number1 = 0;
int number2 = 0;
// семисегментний індикатор
int pindigits [4] = {4,5,6,7};
// змінна для зберігання поточного розряду
int digit = 0;
//
unsigned long millis1 = 0;
void setup ()
{
SPI.begin ();
// Конфігурувати контакти як виходи
pinMode (pin_spi_ss, OUTPUT);
for (int i = 0; i <4; i ++)
{PinMode (pindigits [i], OUTPUT);
digitalWrite (pindigits [i], HIGH);
}
}
void loop ()
{
if (millis () - millis1> = 100)
{Millis1 = millis1 + 100;
number = number + 1;
if (number == 10000)
number = 0;
}
number1 = number;
for (int i = 0; i <4; i ++)
{
number2 = number1% 10;
number1 = number1 / 10;
showNumber (number2, i);
for (int j = 0; j <4; j ++)
digitalWrite (pindigits [j], HIGH);
digitalWrite (pindigits [i], LOW);
delay (1);
}
}
// функція виведення цифри на семисегментний індикатор
void showNumber (int num, int dig)
{
byte maska;
digitalWrite (pin_spi_ss, LOW);
if (dig == 1) maska = 1;
else maska = 0;
SPI.transfer (numbers [num] + maska);
digitalWrite (pin_spi_ss, HIGH);
}
}

9.1

// підключення бібліотеки SPI
#include <SPI.h>
int ss_pin = 8; // пін SS
int pos = 0; //
int offfigure = 0; // поточна фігура для відображення
unsigned long millis1 = 0;
// масив з даними фігур для відображення
byte figure [2] [8] = {
{B10011001, B10011001, B10011001, B10000001, B10000001, B10011001, B10011001, B10011001},
{B10101010, B10101010, B10101010, B10101010, B10101010, B10101010, B10101010, B10101010}
};
void setup ()
{
SPI.begin ();
// Конфігурувати контакт SS як вихід
pinMode (ss_pin, OUTPUT);
}
void loop ()
{
digitalWrite (ss_pin, LOW);
// стовпці
SPI.transfer (B00000001 << pos);
// рядка
SPI.transfer (figure [offfigure] [pos]);
digitalWrite (ss_pin, HIGH); // вивести дані на виводи 74HC595
delay (1);
pos = (pos + 1)% 8;
if (millis () - millis1> 3000) // через 3 секунди - нова фігура
{
offfigure = (offfigure + 1)% 2;
millis1 = millis ();
}
}

10.1

// МЕЛОДІЯ - масив нот і масив тривалостей
char melody [] = { 'G', 'G', 'G', 'E', 'H',
'G', 'E', 'H', 'G', '*',
'D', 'd', 'd', 'e', 'H',
'T', 'E', 'H', 'F',
'G', 'G', 'G', 'g', 't', 'e',
'S', 's', 's', '*', 'U', 'r', 'c', 'B',
'H', 'A', 'H', '*', 'E', 'T', 'E', 'F',
'H', 'G', 'H', 'd',
'G', 'G', 'G', 'g', 't', 'f',
'S', 's', 's', '*', 'U', 'r', 'c', 'B',
'H', 'A', 'H', '*', 'E', 'T', 'E', 'H',
'G', 'E', 'H', 'G',
'%', '%'};
int bb [] = {8,8,8,6,2,
8,6,2,8,8,
8,8,8,6,2,
8,6,2,16,
8,6,2,8,6,2,
2,2,4,4,2,8,6,2,
2,2,4,4,2,8,6,2,
8,6,2,16,
8,6,2,8,6,2,
2,2,4,4,2,8,6,2,
2,2,4,4,2,8,6,2,
8,6,2,16,
64,64};
// підключити динамік до pin 8
int speakerPin = 8;
// темп відтворення, ноти, тривалості
int tempo, notes, beats;
// процедура програшу ноти
void playNote (char note, int duration)
{
// масив для найменувань нот в межах двох октав
char names [] = { 'c', 'r', 'd', 's', 'e', 'f', 't', 'g', 'u', 'a', 'b',
'H', 'C', 'R', 'D', 'S', 'E', 'F', 'T', 'G', 'U', 'A', 'B', 'H ',' F '};
// масив частот нот
int tones [] = {261,277,293,311,329,349,370,392,415,440,466,
494, 523,554,587,622,659,698,740,784,830,880,932,988};
// програти тон, відповідний ноті
for (int i = 0; i <sizeof (tones); i ++)
{
if (names [i] == note)
{
tone (speakerPin, tones [i], duration);
}
}
}
void setup ()
{
pinMode (speakerPin, OUTPUT);
tempo = 50; // швидкість відтворення мелодії
}
void loop ()
{
for (int i = 0; i <sizeof (melody); i ++)
{
notes = melody [i];
beats = bb [i];
if (notes == '*')
tone (speakerPin, 0, beats * tempo); // пауза
else
playNote (notes, beats * tempo);
// пауза між нотами
delay (beats * tempo + tempo);
}
}

11.1

const int MOTOR = 9; // Вихід для підключення MOSFET
const int POT = 0; // Аналоговий вхід A0 для підключення потенціометра
int valpot = 0; // змінна для зберігання значення потенціометра
int speedMotor = 0; // змінна для зберігання швидкості двигуна
void setup ()
{
//
pinMode (MOTOR, OUTPUT);
}
void loop ()
{
valpot = analogRead (POT); // читання даних потенциометра
// масштабується значення до інтервалу 0-255
speedMotor = map (valpot, 0,1023,0,255);
// встановлюємо нове значення ШІМ
analogWrite (MOTOR, speedMotor);
delay (1000); // пауза
}

12.1

int relayPin = 10; // підключення до виводу D10 Arduino
void setup ()
{
pinMode (relayPin, OUTPUT); // налаштувати вивід як вихід (OUTPUT)
}
// функція виконується циклічно нескінченне число разів
void loop ()
{
digitalWrite (relayPin, HIGH); // включити реле
delay (5000);
digitalWrite (relayPin, LOW); // вимкнути реле
delay (5000);
}

13.1

int light; // змінна для зберігання даних фоторезистора
void setup ()
{
Serial.begin (9600);
}
void loop ()
{
light = analogRead (0);
Serial.println (light);
delay (100);
}

13.2

// Контакт підключення світлодіодів
const int leds [] = {3,4,5,6,7,8,9,10};
const int LIGHT = A0; // Контакт A0 для входу фоторезистора
const int MIN_LIGHT = 200; // Нижній поріг освітленості
const int MAX_LIGHT = 900; // верхній поріг освітленості
// Змінна для зберігання даних фоторезистора
int val = 0;
void setup ()
{
// Конфігурувати контакти світлодіодів як вихід
for (int i = 0; i <8; i ++)
pinMode (leds [i], OUTPUT);
}
void loop ()
{
val = analogRead (LIGHT); // Читання показань фоторезистора
// Застосування функції map ()
val = map (val, MIN_LIGHT, MAX_LIGHT, 8, 0);
// обмежуємо, щоб не перевищило кордонів
val = constrain (val, 0, 8);
// запалити кількість світлодіодів, пропорційне освітленості,
// інші згасити
for (int i = 1; i <9; i ++)
{
if (i> = val) // запалити світлодіоди
digitalWrite (leds [i-1], HIGH);
else // загасити світлодіоди
digitalWrite (leds [i-1], LOW);
}
delay (1000); // пауза перед наступним виміром
}

14.1

const int BLUE = 9; // вивід BLUE RGB-світлодіоди
const int GREEN = 10; // вивід GREEN RGB-світлодіоди
const int RED = 11; // вивід RED RGB-світлодіоди
const int lm335 = A0; // для підключення LM335
int MIN_T = 20; // Нижній поріг
int MAX_T = 30; // Верхній поріг
int val = 0;
void setup ()
{
// конфігуруємо виводи світлодіоди як OUTPUT
pinMode (RED, OUTPUT);
pinMode (GREEN, OUTPUT);
pinMode (BLUE, OUTPUT);
}
void loop ()
{
double val = analogRead (lm335); // читання
double voltage = val * 5.0 / 1024; // переклад в вольти
double temp = voltage * 100 - 273.15; // в градуси Цельсія
Serial.print ( "temp =");
Serial.println (temp);
if (temp <MIN_T) // синій колір RGB-світлодіоди
setRGB (0,0,1);
else if (temp> MIN_T) // червоний колір RGB-світлодіоди
setRGB (1,0,0);
else // жовтий колір RGB-світлодіоди
setRGB (1,0,0);
delay (1000); // пауза перед наступним виміром
}
// установка кольору RGB-світлодіоди
void setRGB (int r, int g, int b)
{
digitalWrite (RED, r);
digitalWrite (GREEN, g);
digitalWrite (BLUE, b);
}

15.1

// Підключення бібліотеки
#include <LiquidCrystal.h>
// ініціалізація із зазначенням контактів підключення
LiquidCrystal lcd (12, 11, 7, 6, 5, 4);
const int LM335 = A0; // для підключення LM335
void setup () {
// встановити розмірність дисплея
lcd.begin (16, 2);
}
void loop ()
{
double val = analogRead (LM335); // читання
double voltage = val * 5.0 / 1024; // переклад в вольти
// вивід значення в Кельвінах
lcd.setCursor (2,0);
lcd.print ( "Tk ="); lcd.print (voltage * 100); lcd.print ( "K");
double temp = voltage * 100 - 273.15; // в градуси Цельсія
// вивід значення в градусах Цельсія
lcd.setCursor (2,1);
lcd.print ( "Tc ="); lcd.print (temp); lcd.print ( "");
delay (1000); // пауза перед наступним виміром
}

16.1

// Підключення бібліотеки
#include <Adafruit_GFX.h>
#include <Adafruit_PCD8544.h>
// PIN 7 - RST Pin 1 on LCD
// PIN 6 - CE Pin 2 on LCD
// PIN 5 - DC Pin 3 on LCD
// PIN 4 - DIN Pin 4 on LCD
// PIN 3 - CLK Pin 5 on LCD
Adafruit_PCD8544 display = Adafruit_PCD8544 (3, 4, 5, 6, 7);
const int LIGHT = A0; // Контакт A0 для входу фоторезистора
const int MIN_LIGHT = 200; // Нижній поріг освітленості
const int MAX_LIGHT = 900; // Верхній поріг освітленості
// Змінна для зберігання даних фоторезистора
int val1, val2 = 0;
void setup ()
{
display.begin ();
// встановити контраст фону екрану
// дуже важливий параметр!
display.setContrast (60);
display.clearDisplay (); // очистити екран
delay (2000);
}
void loop ()
{
val1 = analogRead (LIGHT); // Читання показань фоторезистора
drawText (val1,1); // вивести текст
// масштабування значення потенціометра до 0-75
val2 = map (val1, MIN_LIGHT, MAX_LIGHT, 0, 75);
// вивід чорного прямокутника в%
display.fillRect (5, 25, val2, 10, 1);
// вивід білої частини прямокутника
display.fillRect (5 + val2,25, 75-val2, 10, 0);
display.display ();
delay (1000); // пауза перед новим виміром
drawText (val1,2); // стерти текст
}
// процедура виведення тексту
void drawText (unsigned long num, int color)
{
display.setTextSize (2); // розмір шрифту
display.setCursor (20,5); // позиція курсору
if (color == 1)
display.setTextColor (BLACK); // вивести значення
else
display.setTextColor (WHITE); // стерти (білим по білому)
display.print (num);
}

17.1

#include <Servo.h> // підключення бібліотеки Servo
Servo servo1;
const int pinServo = 8; // Пін для підключення сервоприводу
const int POT = 0; // Аналоговий вхід A0 для підключення потенціометра
int valpot = 0; // змінна для зберігання значення потенціометра
int angleServo = 0; // змінна для зберігання кута повороту серви
void setup ()
{
// підключити змінну servo до виводу pinServo
servo1.attach (pinServo);
}
void loop ()
{
valpot = analogRead (POT); // читання даних потенциометра
// масштабується значення до інтервалу 0-180
angleServo = map (valpot, 0,1023,0,180);
// поворот сервоприводу на отриманий кут
servo1.write (angleServo);
delay (15); // пауза для очікування повороту сервоприводу
}

18.1

const int axisX = A0 // вісь Х підключена до A0
const int axisY = A1 // вісь Y підключена до A1
const int axisZ = 2 // вісь Z (кнопка джойстика) підключена до D2
int valX, valY, valZ = 0; // змінні для зберігання значень осей
void setup ()
{
pinMode (axis_Z, INPUT_PULLUP); // конфігуруємо D2 як INPUT з включенням
// підтягує резистора всередині процесора
Serial.begin (9600);
}
void loop () {
valX = analogRead (axisX); // значення осі Х
valY = analogRead (axisY); // значення осі Y
valZ = 1-digitalRead (axisZ); // значення осі Z (кнопка)
// виводимо значення в монітор
Serial.print ( "X:"); Serial.print (valX, DEC);
Serial.print ( "| Y:"); Serial.print (valY, DEC)
Serial.print ( "| Z:"); Serial.println (valZ, DEC);
delay (500); // пауза перед наступним зчитуванням даних
}

18.2

#include <Servo.h> // підключення бібліотеки Servo
Servo servo1, servo2;
const int pinServo1 = 8; // Пін для підключення 1 сервоприводу
const int pinServo2 = 9; // Пін для підключення 2 сервоприводу
// змінні для зберігання кутів повороту сервоприводів
int angleServo1, angleServo2 = 0;
const int axisX = A0; // вісь Х підключена до A0
const int axisY = A1; // вісь Y підключена до A1
int valX, valY = 0; // змінні для зберігання значень осей
void setup ()
{
// підключити змінну servo1 до виводу pinServo1
servo1.attach (pinServo1);
// підключити змінну servo2 до виводу pinServo2
Servo2.attach (pinServo2);
}
void loop ()
{
valX = analogRead (axisX); // значення осі Х
valY = analogRead (axisY); // значення осі Y
// масштабується значення до інтервалу 0-180
angleServo1 = map (valX, 0,1023,0,180);
angleServo2 = map (valY, 0,1023,0,180);
// поворот сервоприводів на отриманий кут
servo1.write (angleServo1);
servo2.write (angleServo2);
delay (15); // пауза для очікування повороту сервоприводів
}

19.1

// підключення бібліотек для RTC
#include <Wire.h>
#include <Time.h>
#include <DS1307RTC.h>
// підключення бібліотеки для SD
#include <SD.h>
File myFile;
String sfilename;
char filename [20];
const int LM335 = A0; // для підключення LM335
tmElements_t tm;
unsigned long millis1 = 0;
void setup ()
{;}
void loop ()
{
// перевірка пройшло 5 хвилин?
if (millis () - millis1> 5 * 60 * 000)
{
millis1 = millis ();
// отримати ім'я файлу для поточного дня
sfilename = get_file_name ();
sfilename.toCharArray (filename, 20);
// відкрити файл або створити
myFile = SD.open (filename, FILE_WRITE);
// отримати температуру
double val = analogRead (lm335); // читання
double voltage = val * 5.0 / 1024; // переклад в вольти
double temp = voltage * 100 - 273.15; // в градуси Цельсія
// отримати час H: m
// створити запис для файлу
record = get_time ();
record + = "";
record + = String (temp);
myFile.println (record);
myFile.close ();
}
// отримання часу дня
String get_time ()
{
String time1;
RTC.read (tm);
if (tm.Hour () <10)
time1 = "0" + String (tm.Hour (), DEC);
else
time1 = String (tm.Hour (), DEC);
if (tm.Minute () <10)
time1 + = ": 0" + String (tm.Minute (), DEC);
else
time1 + = ":" + String (tm.Minute (), DEC);
return time1;
}

20.1

#include <OneWire.h>
OneWire ds (10); // лінія 1-Wire буде на pin 10
#include <LiquidCrystal.h>
// ініціалізація із зазначенням контактів підключення
LiquidCrystal lcd (12, 11, 7, 6, 5, 4);
void setup (void)
{
Serial.begin (9600);
// встановити розмірність дисплея
lcd.begin (16, 2);
lcd.clear ();
}
void loop (void)
{
int t = get_temp ();
lcd.setCursor (0,1); lcd.print ( "");
lcd.setCursor (0,1);
lcd.print (t / 16); lcd.print ( "."); lcd.print ((t% 16) * 100/16);
}
// отримання даних з датчика DS18B20
int get_temp ()
{
byte i;
byte present = 0;
byte data [12];
byte addr [8];
int Temp;
if (! ds.search (addr))
{Serial.print ( "No more addresses. \ N");
ds.reset_search ();
return -1;
}
// вивід в монітор унікальну адресу 1-Wire пристрої
lcd.setCursor (0,0);
lcd.print ( "R =");
for (i = 0; i <8; i ++)
{Lcd.print (addr [i], HEX); lcd.print ( "");}
if (OneWire: crc8 (addr, 7)! = addr [7])
{
Serial.print ( "CRC is not valid! \ N");
return -1;
}
if (addr [0]! = 0x28)
{
Serial.print ( "Device is not a DS18S20 family device. \ N");
return -1;
}
ds.reset ();
// запустити конвертацію температури датчиком
ds.write (0x44,1);
delay (750); // чекаємо 750 мс
present = ds.reset ();
ds.select (addr);
ds.write (0xBE); /
// зчитуємо ОЗУ датчика
for (i = 0; i <9; i ++)
{Data [i] = ds.read ();}
Temp = (data [1] << 8) + data [0];
return Temp;
}

21.1

#include "DHT.h"
#define DHTPIN 2 // пін підключення контакту DATA
#define DHTTYPE DHT11 // DHT 11
#include <LiquidCrystal.h>
// ініціалізація із зазначенням контактів підключення
LiquidCrystal lcd (12, 11, 7, 6, 5, 4);
DHT dht (DHTPIN, DHTTYPE);
void setup ()
{
lcd.begin (16,2); // режим роботи
dht.begin ();
}
void loop ()
{
// отримання з датчика даних вологості і температури
float h = dht.readHumidity ();
float t = dht.readTemperature ();
if (isnan (t) || isnan (h)) // помилка отримання даних
{
lcd.clear (); lcd.setCursor (0,0);
lcd.print ( "Failed to read");
}
else // вивести дані на РКІ
{
lcd.clear ();
lcd.setCursor (0,0);
lcd.print ( "Humidity:"); lcd.print (h); lcd.println ( "%");
lcd.setCursor (0,1);
lcd.print ( "Temp:"); lcd.print (t); lcd.println ( "* C");
}
delay (2000); // пауза перед наступним виміром
}

22.1

// контакт підключення аналогового виведення MQ4
const int analogInPin = A1;
const int ledPin = 8; // контакт підключення світлодіода
int sensorValue = 0; // змінна для зберігання значення датчика
void setup ()
{
Serial.begin (9600);
pinMode (ledPin, OUTPUT);
}
void loop ()
{
sensorValue = analogRead (analogInPin); // отримати значення
if (sensorValue> = 750) // перевищення рівня
digitalWrite (ledPin, HIGH); // запалити світлодіод перевищення
else
digitalWrite (ledPin, LOW); // загасити світлодіод перевищення
// вивести значення в послідовний порт
Serial.print ( "sensor =");
Serial.println (sensorValue); // пауза перед наступним виміром
delay (1000);
}

23.1

#include // підключення бібліотеки Servo
Servo servo1;
const int pinServo = 8; // пін для підключення сервоприводу
int pos = 0; // змінна для зберігання позиції сервоприводу
int dir = 1; // напрям переміщення сервоприводу
// виводи для підключення HC-SR04 Trig - 12, Echo - 13
Ultrasonic ultrasonic (12, 13);
float dist_cm; // змінна для дистанції, см
// підключити динамік до pin 9
int speakerPin = 9;
void setup ()
{
// підключити змінну servo1 до виводу pinServo1
servo1.attach (pinServo1);
pinMode (speakerPin, OUTPUT);
}
void loop ()
{
servo1.write (pos); // поворот сервоприводів на отриманий кут
delay (15); // пауза для очікування повороту сервоприводів
float dist_cm = ultrasonic.Ranging (CM);
if (dist_cm 20)
tone (speakerPin,); // включити Пьезозуммер
else
{
tone (speakerPin, 0); // відключити Пьезозуммер
pos = pos + dir; // зміна змінної положення сервоприводу
if (pos == 0 || pos == 180)
dir = dir * (- 1); // зміна напрямку руху
}
}

24.1

// підключення бібліотек
#include "I2Cdev.h"
#include "MPU6050.h"
#include "Wire.h"
MPU6050 accelgyro;
int16_t ax, ay, az;
int16_t gx, gy, gz;
void setup ()
{

}
Wire.begin ();
Serial.begin (38400);
// ініціалізація
Serial.println ( "Initializing I2C devices ...");
accelgyro.initialize ();
delay (100);
}
void loop ()
{
// читання значень гіроскопа і акселерометра
accelgyro.getMotion6 (& ax, & ay, & az, & gx, & gy, & gz);
// вивід значень в монітор
Serial.print ( "a / g: \ t");
Serial.print (ax); Serial.print ( "\ t");
Serial.print (ay); Serial.print ( "\ t");
Serial.print (az); Serial.print ( "\ t");
Serial.print (gx); Serial.print ( "\ t");
Serial.print (gy); Serial.print ( "\ t");
Serial.println (gz);
}

25.1

#include <IRremote.h> // підключення бібліотеки
int RECV_PIN = 1; // контакт підключення ІЧ-приймача
IRrecv irrecv (RECV_PIN);
decode_results results;
void setup ()
{
Serial.begin (9600);
irrecv.enableIRIn (); // включити приймач
}
void loop ()
{
if (irrecv.decode (& results))
{
Serial.println (results.value, HEX);
irrecv.resume (); // отримати таке значення
}
}

25.2

// коди клавіш інфрачервоного пульта
#define K2 тисячі дев'ятсот тридцять шість
#define K3 3984
#define K4 144
#define K5 2192
#define K6 3472
#define K7 тисяча чотиреста двадцять чотири
#define K8 3216
#define K9 +1168
#include <IRremote.h> // підключення бібліотеки
int RECV_PIN = 1; // контакт підключення ІЧ-приймача
IRrecv irrecv (RECV_PIN);
decode_results results;
// значення на D2 - D9 Arduino
int val_pins [] = {0,0,0,0,0,0,0,0};
int res = 0;
void setup ()
{
Serial.begin (9600);
irrecv.enableIRIn (); // включити приймач
for (int i = 2; i <10; i ++)
{
pinMode (i, OUTPUT);
digitalWrite (i, LOW);
}
}
void loop ()
{
if (irrecv.decode (& results))
{
switch (results.value)
{
case K2: res = 2; break;
case K3: res = 3; break;
case K4: res = 4; break;
case K5: res = 5; break;
case K6: res = 6; break;
case K7: res = 7; break;
case K8: res = 8; break;
case K9: res = 9; break;
default: res = 0; break;
}
if (res> 0)
{
pins [res-2] = 1 pins [res-2];
// переключити світлодіод
digitalWrite (res, pins [res-2]);
}
irrecv.resume (); // отримати таке значення
}
}

26.1

// підключення бібліотек для RTC
#include <Wire.h>
#include <Time.h>
#include <DS1307RTC.h>
// підключення бібліотеки для lcd
#include <LiquidCrystal.h>
// ініціалізація із зазначенням контактів підключення
LiquidCrystal lcd (9, 8, 7, 6, 5, 4);
void setup ()
{
lcd.begin (16, 2); // встановити розмірність дисплея
}
void loop ()
{
tmElements_t tm;
if (RTC.read (tm)) // отримання часу
{
print2digits (tm.Hour, 0,0);
lcd.print ( ":");
print2digits (tm.Minute, 3,0);
lcd.print ( ":");
print2digits (tm.Second, 6,0);
print2digits (tm.Day, 0,1);
lcd.print ( "/");
print2digits (tm.Month, 3,1);
lcd.print ( "/");
lcd.print (tmYearToCalendar (tm.Year));
}
else
{
if (RTC.chipPresent ())
{
lcd.clear ();
lcd.setCursor (0, 0);
lcd.print ( "DS1307 is stopped");
}
else
{
lcd.clear ();
lcd.setCursor (0, 0);
lcd.print ( "DS1307 read error");
}
delay (9000);
}
delay (1000);
}
// процедура виведення на дисплей з додаванням до двох цифр
void print2digits (int number, int col, int str)
{
lcd.setCursor (col, str);
if (number> = 0 && number <10)
{Lcd.print ( "0");}
lcd.print (number);
}

26.2

// підключення бібліотек для RTC
#include <Wire.h>
#include <Time.h>
#include <DS1307RTC.h>
// підключення бібліотеки для lcd
#include <LiquidCrystal.h>
// ініціалізація із зазначенням контактів підключення
LiquidCrystal lcd (9, 8, 7, 6, 5, 4);
// рядок, що збирається з даних, що приходять в послідовний порт
String inputString = "";
boolean stringComplete = false; // прапор комплектності рядки
void setup ()
{
Serial.begin (9600); // запустити послідовний порт
lcd.begin (16, 2); // встановити розмірність дисплея
}
void loop ()
{
tmElements_t tm;
// очікування кінця рядка для аналізу надійшов запиту:
if (stringComplete)
{
tm.Day = (int (inputString [0]) - 48) * 10 + (int (inputString [1]) - 48);
tm.Month = (int (inputString [3]) - 48) * 10 + (int (inputString [4]) - 48);
tm.Year = CalendarYrToTm ((int (inputString [6]) -
48) * 1000 + (int (inputString [7]) - 48) * 100 +
(Int (inputString [8]) - 48) * 10 + (int (inputString [9]) - 48));
tm.Hour = (int (inputString [11]) - 48) * 10 + (int (inputString [12]) - 48);
tm.Minute = (int (inputString [14]) - 48) * 10 + (int (inputString [15]) - 48);
tm.Second = (int (inputString [17]) - 48) * 10 + (int (inputString [18]) - 48);
RTC.write (tm); // записати час в RTC
// очистити рядок
inputString = "";
stringComplete = false;
}
if (RTC.read (tm))
{
print2digits (tm.Hour, 0,0);
lcd.print ( ":");
print2digits (tm.Minute, 3,0);
lcd.print ( ":");
print2digits (tm.Second, 6,0);
print2digits (tm.Day, 0,1);
lcd.print ( "/");
print2digits (tm.Month, 3,1);
lcd.print ( "/");
lcd.print (tmYearToCalendar (tm.Year));
}
else
{
if (RTC.chipPresent ())
{
lcd.clear ();
lcd.setCursor (0, 0);
lcd.print ( "DS1307 is stopped");
}
else
{
lcd.clear ();
lcd.setCursor (0, 0);
lcd.print ( "DS1307 read error");
}
delay (9000);
}
delay (1000);
}
// процедура виведення на дисплей з додаванням до двох цифр
void print2digits (int number, int col, int str)
{
lcd.setCursor (col, str);
if (number> = 0 && number <10)
{Lcd.print ( "0");}
lcd.print (number);
}
// отримання даних по послідовному порту
void serialEvent ()
{
while (Serial.available ())
{// отримати черговий байт:
char inChar = (char) Serial.read ();
// додати в рядок
inputString + = inChar;
// / n - кінець передачі
if (inChar == '\ n')
{StringComplete = true;}
}
}

27.1

28.1

// Підключення бібліотек
#include <SPI.h>
#include <MFRC522.h>
// константи підключення контактів SS і RST
#define RST_PIN 9
#define SS_PIN 10
// Ініціалізація MFRC522
MFRC522 mfrc522 (SS_PIN, RST_PIN); // Create MFRC522 instance.
void setup ()
{
Serial.begin (9600); // ініціалізація послідовного порту
SPI.begin (); // ініціалізація SPI
mfrc522.PCD_Init (); // ініціалізація MFRC522
}
void loop ()
{
if (! mfrc522.PICC_IsNewCardPresent ())
return;
// читання карти
if (! mfrc522.PICC_ReadCardSerial ())
return;
// показати результат читання UID і тип мітки
Serial.print (F ( "Card UID:"));
dump_byte_array (mfrc522.uid.uidByte, mfrc522.uid.size);
Serial.println ();
Serial.print (F ( "PICC type:"));
byte piccType = mfrc522.PICC_GetType (mfrc522.uid.sak);
Serial.println (mfrc522.PICC_GetTypeName (piccType));
delay (2000);
}
// вивід результату читання даних в HEX-вигляді
void dump_byte_array (byte * buffer, byte bufferSize)
{
for (byte i = 0; i <bufferSize; i ++)
{
Serial.print (buffer [i] <0x10? "0": "");
Serial.print (buffer [i], HEX);
}
}

28.2

// Підключення бібліотек
#include <SPI.h>
#include <MFRC522.h>
// константи підключення контактів SS і RST
#define RST_PIN 9
#define SS_PIN 10
// Ініціалізація MFRC522
MFRC522 mfrc522 (SS_PIN, RST_PIN); // Create MFRC522 instance.
MFRC522: MIFARE_Key key;
byte sector = 1;
byte blockAddr = 4;
byte dataBlock [] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
byte trailerBlock = 7;
byte status;
byte buffer [18];
byte size = sizeof (buffer);
void setup ()
{
Serial.begin (9600); // ініціалізація послідовного порту
SPI.begin (); // ініціалізація SPI
mfrc522.PCD_Init (); // ініціалізація MFRC522
// Значення ключа (A або B) - FFFFFFFFFFFFh значення з заводу
for (byte i = 0; i <6; i ++)
key.keyByte [i] = 0xFF;
}
void loop ()
{
if (! mfrc522.PICC_IsNewCardPresent ())
return;
// читання карти
if (! mfrc522.PICC_ReadCardSerial ())
return;
// показати результат читання UID і тип мітки
Serial.print (F ( "Card UID:"));
dump_byte_array (mfrc522.uid.uidByte, mfrc522.uid.size);
Serial.println ();
Serial.print (F ( "PICC type:"));
byte piccType = mfrc522.PICC_GetType (mfrc522.uid.sak);
Serial.println (mfrc522.PICC_GetTypeName (piccType));
// Читання даних з блоку 4
Serial.print (F ( "Reading data from block"));
Serial.print (blockAddr);
Serial.println (F ( "..."));
Serial.print (F ( "Data for count")); Serial.print (blockAddr);
Serial.println (F ( ":"));
dump_byte_array (buffer, 2); Serial.println ();
Serial.println ();
for (byte i = 0; i <16; i ++) // запис в buffer []
dataBlock [i] = buffer [i];
// отримання байт лічильника (0 і 1)
int count1 = (buffer [0] << 8) + buffer [1];
Serial.print ( "count1 ="); Serial.println (count1);
count1 = count1 + 1; // інкремент лічильника
dataBlock [0] = highByte (count1);
dataBlock [1] = lowByte (count1);
// Аутентификация key B
Serial.println (F ( "Authenticating again using key B ..."));
// Запис даних в блок
Serial.print (F ( "Writing data into block"));
Serial.print (blockAddr);
Serial.println (F ( "..."));
dump_byte_array (dataBlock, 2); Serial.println ();
}
// вивід результату читання даних в HEX-вигляді
void dump_byte_array (byte * buffer, byte bufferSize)
{
for (byte i = 0; i <bufferSize; i ++)
{
Serial.print (buffer [i] <0x10? "0": "");
Serial.print (buffer [i], HEX);
}
}

29.1

#include <SPI.h>
#include <Ethernet.h>
// mac-адресу плати і ip-адреса сервера
byte mac [] = {0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED};
IPAddress ip (192,168,0,214);
// Initialize the Ethernet server library
// with the IP address and port you want to use
// (port 80 is default for HTTP):
EthernetServer server (80);
int pins [] = {7, 8}; // Піни для світлодіодів
int pinState [] = {0, 0}; // Стан пинов
String getData = "";
boolean startGet = false;
void setup ()
{
Serial.begin (9600);
for (int i = 0; i <2; i ++)
{
pinMode (pins [i], OUTPUT); // контакти підключення світлодіодів
digitalWrite (i, LOW); // вимкнути світлодіоди
}
// ініціалізації бібліотеки Ethernet server
Ethernet.begin (mac, ip);
server.begin ();
}
void loop ()
{
// очікування підключення клієнтів
EthernetClient client = server.available ();
if (client)
{
boolean currentLineIsBlank = true;
while (client.connected ())
{
if (client.available ())
{
char c = client.read ();
if (startGet == true) // дані після '?'
getData + = c;
if (c == '?') // початок збору даних після '?'
startGet = true;
if (c == '\ n' && currentLineIsBlank) // закінчення отримання
{
if (getData.length () <1) // запит без get-даних
{
pinState [0] = 0;
pinState [1] = 0;
}
else
{
pinState [0] = int (getData [5]) - 48;
pinState [1] = int (getData [12]) - 48;
}
// відправка заголовків клієнту
client.println ( "HTTP / 1.1 200 OK");
client.println ( "Content-Type: text / html");
client.println ( "Connection: close");
client.println ();
// формування сторінки відповіді
client.println ( "<! DOCTYPE HTML>");
client.println ( "<html>");
client.println ( "<h3> Ethernet shield + LEDS </ h3>");
client.println ( "<form method = 'get'>");
// світлодіод 1
client.print ( "<div>");
client.print ( "led1 off <input type = 'radio' name = 'led1' value = 0
onclick = 'document.getElementById (\ "submit \"). click ();' ");
if (pinState [0] == 0)
client.print ( "checked");
client.println ( ">");
client.print ( "<input type = 'radio' name = 'led1' value = 1
onclick = 'document.getElementById (\ "submit \"). click ();' ");
if (pinState [0] == 1)
client.print ( "checked");
client.println ( "> on");
client.println ( "</ div>");
// світлодіод 2
client.print ( "<div>");
client.print ( "led2 off <input type = 'radio' name = 'led2' value = 0
onclick = 'document.getElementById (\ "submit \"). click ();' ");
if (pinState [1] == 0)
client.print ( "checked");
client.println ( ">");
client.print ( "<input type = 'radio' name = 'led2' value = 1
onclick = 'document.getElementById (\ "submit \"). click ();' ");
if (pinState [1] == 1)
client.print ( "checked");
client.println ( "> on");
client.println ( "</ div>");
client.println ( "<input type = 'submit' id = 'submit'
style = 'visibility: hidden;' value = 'Refresh'> ");
client.println ( "</ form>");
client.println ( "</ html>");
break;
}
if (c == '\ n')
{CurrentLineIsBlank = true;}
else if (c! = '\ r')
{CurrentLineIsBlank = false;}
}
}
}
// затримка для отримання клієнтом даних
delay (1);
// закрити з'єднання
client.stop ();
for (int i = 0; i <2; i ++) // світлодіоди включити або вимкнути
{DigitalWrite (pins [i], pinState [i]);}
startGet = false;
getData = "";
}

30.1

#include <SoftwareSerial.h>
SoftwareSerial mySerial (2, 3); // вказуємо Піни rx і tx
void setup ()
{
pinMode (2, INPUT);
pinMode (3, OUTPUT);
Serial.begin (9600);
mySerial.begin (9600);
}
void loop ()
{
if (mySerial.available ())
{
int c = mySerial.read (); // читаємо з software-порту
Serial.write (c); // пишемо в hardware-порт
if (Serial.available ())
{
int c = Serial.read (); // читаємо з hardware-порту
mySerial.write (c); // пишемо в software-порт
}
}

30.2

#include <SoftwareSerial.h>
SoftwareSerial mySerial (2, 3); // RX, TX
const int LM335 = A0; // контакт підключення датчика LM335
#define SSID "MacBook Pro - Petin" // введіть ваш SSID
#define PASS "19101966" // введіть ваш пароль
#define DST_IP "92.39.235.156" // naronmon.ru
void setup ()
{
Serial.begin (9600); // для налагодження
mySerial.begin (9600);
delay (2000);
Serial.println ( "Init");
mySerial.println ( "AT + RST"); // скидання і перевірка, якщо модуль готовий
delay (1000);
if (mySerial.find ( "ready"))
{Serial.println ( "WiFi - Module is ready");}
else
{Serial.println ( "Module dosn't respond.");
while (1);
}
delay (1000);
// з'єднання по wifi
boolean connected = false;
for (int i = 0; i <5; i ++)
{
if (connectWiFi ())
{Connected = true;
mySerial.println ( "Connected to Wi-Fi ...");
break;
}
}
if (! connected)
{
mySerial.println ( "Coudn't connect to Wi-Fi.");
while (1);
}
delay (5000);
mySerial.println ( "AT + CIPMUX = 0"); // режим одиночного з'єднання
}
void loop ()
{
String cmd = "AT + CIPSTART = \" TCP \ ", \" ";
cmd + = DST_IP;
cmd + = "\", 8283 ";
Serial.println (cmd);
mySerial.println (cmd);
if (mySerial.find ( "Error"))
return;
double val = analogRead (LM335); // читання показань LM335
double voltage = val * 5.0 / 1024; // переклад в вольти
double temp = voltage * 100 - 273.15; // в градуси Цельсія
cmd = "# A0: F3: C1: 70: AA: 94 \ n # 2881C4BA0200003B1 #" + String (temp) + "\ n ##";
delay (3000);
mySerial.print ( "AT + CIPSEND =");
mySerial.println (cmd.length ());
delay (1000);
Serial.println ( ">");
mySerial.print (cmd);
Serial.println (cmd);
delay (3000);
mySerial.println ( "AT + CIPCLOSE");
delay (600000);
}
// процедура установки Wi-Fi-з'єднання
boolean connectWiFi ()
{
String cmd = "AT + CWJAP = \" ";
cmd + = SSID;
cmd + = "\", \ "";
cmd + = PASS;
cmd + = "\" ";
mySerial.println (cmd);
Serial.println (cmd);
delay (2000);
if (mySerial.find ( "OK"))
{
Serial.println ( "OK, Connected to Wi-Fi.");
return true;
}
else
{
Serial.println ( "Can not connect to the Wi-Fi.");
return false;
}
}

31.1

#include <SoftwareSerial.h>
SoftwareSerial mySerial (2, 3); // вказуємо Піни RX і TX
void setup ()
{
pinMode (2, INPUT);
pinMode (3, OUTPUT);
Serial.begin (38400);
mySerial.begin (9600);
}
void loop ()
{
if (mySerial.available ())
{
int c = mySerial.read (); // читаємо з software-порту
Serial.write (c); // пишемо в hardware-порт
}
if (Serial.available ())
{
int c = Serial.read (); // читаємо з hardware-порту
mySerial.write (c); // пишемо в software-порт
}
}
}

32.1

// підключення бібліотеки SoftwareSerial
#include <SoftwareSerial.h>
// номер телефону для відправки sms (поміняйте на свій)
#define PHONE "+79031111111"
// виводи для SoftwareSerial (у вас можуть бути 7,8)
SoftwareSerial Sim900Serial (2, 3);
const int lm335 = A0; // для підключення LM335
unsigned long millis1;
void setup ()
{
Sim900Serial (19200); // the Hardware serial rate
}
void loop ()
{
if (millis () - millis1> 30 * 60 * 1000) // пройшло 30 хвилин?
{
SendTextMessage (); // відправити sms
millis1 = millis ();
}
}
// підпрограма відправки sms
void SendTextMessage ()
{
// AT-команда установки text mode
Sim900Serial.print ( "AT + CMGF = 1 \ r");
delay (100);
// номер телефону одержувача
Sim900Serial.println ( "AT + CMGS = \" ");
Sim900Serial.println (PHONE);
Sim900Serial.println ( "\" ");
delay (100);
// повідомлення - дані температури
double val = analogRead (lm335); // читання
double voltage = val * 5.0 / 1024; // переклад в вольти
double temp = voltage * 100 - 273.15; // в градуси Цельсія
Sim900Serial.println (temp);
delay (100);
// ASCII код ctrl + z - закінчення передачі
Sim900Serial.println ((char) 26);
delay (100);
Sim900Serial.println ();
}

32.2

#include <SoftwareSerial.h>
SoftwareSerial Sim900Serial (2, 3);
String currStr = ""; //
String phone = ""; //
// True, якщо поточна рядок є sms-повідомленням
boolean isStringMessage = false;
void setup ()
{
Serial.begin (19200);
Sim900Serial.begin (19200);
// Налаштовуємо прийом повідомлень з інших пристроїв
Sim900Serial.print ( "AT + CMGF = 1 \ r");
delay (300);
Sim900Serial.print ( "AT + IFC = 1, 1 \ r");
delay (300);
Sim900Serial.print ( "AT + CPBS = \" SM \ "\ r");
delay (300);
Sim900Serial.print ( "AT + CNMI = 1,2,2,1,0 \ r");
delay (500);
}
void loop ()
{
if (! Sim900Serial.available ())
return;
char currSymb = Sim900Serial.read ();
if ( '\ r' == currSymb)
{
if (isStringMessage) // поточна рядок - sms-повідомлення,
{
if (! currStr.compareTo ( "temp")) // текст sms - temp
{
// відправити sms на приходить номер
Sim900Serial.print ( "AT + CMGF = 1 \ r");
delay (100);
Sim900Serial.print ( "AT + CMGS = \" ");
Sim900Serial.print (phone);
Sim900Serial.println ( "\" ");
delay (100);
double val = analogRead (A0); // читання
double voltage = val * 5.0 / 1024; // переклад в вольти
double temp = voltage * 100 - 273.15; // в градуси Цельсія
Serial.println (temp);
Sim900Serial.println (temp);
delay (100);
Sim900Serial.println ((char) 26);
delay (100);
Sim900Serial.println ();
}
Serial.println (currStr);
isStringMessage = false;
}
else
{
if (currStr.startsWith ( "+ CMT")) {
Serial.println (currStr);
// виділити з повідомлення номер телефону
phone = currStr.substring (7,19);
Serial.println (phone);
// якщо поточний рядок починається з "+ CMT",
// то наступний рядок є повідомленням
isStringMessage = true;
}
}
currStr = "";
}
else if ( '\ n'! = currSymb)
{
currStr + = String (currSymb);
}

33.1

#include <SoftwareSerial.h>
#include <TinyGPS.h>
TinyGPS gps;
SoftwareSerial gpsSerial (7, 8);
bool newdata = false;
unsigned long start;
long lat, lon;
unsigned long time, date;
void setup ()
{
gpsSerial.begin (9600); // швидкість обміну з GPS-приймачем
Serial.begin (9600);
Serial.println ( "Waiting data of GPS ...");
}
void loop ()
{
// затримка в секунду між оновленнями координат
if (millis () - start> 1000)
{
newdata = readgps ();
if (newdata)
{
start = millis ();
gps.get_position (& lat, & lon);
gps.get_datetime (& date, & time);
Serial.print ( "Lat:"); Serial.print (lat);
Serial.print ( "Long:"); Serial.print (lon);
Serial.print ( "Date:"); Serial.print (date);
Serial.print ( "Time:"); Serial.println (time);
}
}
}
// перевірка наявності даних
bool readgps ()
{
while (gpsSerial.available ())
{
int b = gpsSerial.read ();
// в TinyGPS є помилка: не обробляються дані з \ r і \ n
if ( '\ r'! = b)
{
if (gps.encode (b))
return true;
}
}
return false;
}
}