Зумер і мелодії

Вступ

Окрім тактильних (кнопки) і візуальних (світлодіоди) способів взаємодії з Дроном, існують ще й інші. Наприклад, один з таких, який ми розглянемо на цьому уроці – звуковий (або акустичний). Звуки дуже важливі і широко використовуються в різноманітних побутових пристроях. Наприклад, мікрохвильовки не просто так мають гучні пищалки. Коли ви увімкнули підігрів їжі на кілька хвилин і пішли в іншу кімнату, то немає іншого більш дієвого способу повідомити Вам про закінчення підігріву окрім як голосно запищати. Простим миганням світлодіоду тут не обійтися, оскільки Ви навряд його побачите з іншої кінмати. Інший приклад це якщо забути закрити дверцята холодильника, то більш-менш сучасні холодильники запищать, попереджуючи Вас, щоб продукти не розморозились і не було катастрофи на кухні. Ще один приклад це детектори диму, які подавши звуковий сигнал, завчасно попереджують про пожежу

Пищалка



Пищалки, або їх ще називають зумери чи бузери, це складніші пристрої для керування ніж світлодіоди. У випадку світлодіодів в попередніх уроках ми передавали одиницю в функцію digitalWrite і все – цього було достатньо для увімкнення світлодіоду. Що робив Дрон під капотом то це підключав напругу в кілька вольт на світлодіод і він вмикався. Для того, щоб увімкнути пищалку (бузер), потрібно передавати не просто напругу, а коливаючу напругу з певною частотою. Яку частоту напруги передаєш на пищалку, таку вона вона і відтворює у вигляді звуків

Людське вухо може сприймати звуки з частотою в діапазоні від 20 Гц (Герц) до 20 тисяч Гц. Але найкраще людина сприймає звуки у діапазоні частот від 2000 до 5000 Гц. Саме ці частоти відповідають людській мові. Тому за роки еволюції людина навчилась дуже добре чути саме їх, щоб краще чути співрозмовника. Отже тепер ми знаємо, що для того, щоб нам почути звуки треба заставити Дрон звучати з певною частотою. На щастя і для цього існує функція, яка вміє це робити, треба лише передати їй в параметри частоту, з якою ми хочемо, щоб пищалка звучала і тривалість звучання. Ця функція називається tone

Написання програми

Давайте напишемо програму, яка буде періодично видавати звук з частотою 500 Гц на пін PA6, до якого підключимо пищалку

​
1void setup() {
2  pinMode(PA6, OUTPUT);
3}
4
5void loop() {
6  tone(PA6, 500, 300);
7  delay(2000);
8}
1void setup() {         //Функція 'setup' виконується першою при запуску Дрона і лише раз
2  pinMode(PA6, OUTPUT);//переводимо пін пищалки в режим роботи на вихід
3}
4
5void loop() {          //Функція 'loop' виконується циклічно і безкінечно одразу після 'setup'
6  tone(PA6, 500, 300); //Вмикаємо звучання піна PA6 з частотою 500 Гц впродовж 300 мілісекунд
7  delay(2000);         //чекаємо наприклад 2 секунди до наступного пищання
8}

Отже, як видно з прикладу вище, функція tone приймає 3 можливі параметри: номер піна (PA6), частота звучання (500 Гц), тривалість звучання (300 мс). Як ми вже знаємо, в одній секунді – 1000 мілісекунд

Дрон сам по собі не має пищалки (зумера), але його можна підключити як зовнішній модуль до піна PA6 Дрона. Після підключення пищалки переведіть Дрон в режим програмування (див. 1-ий урок), скопіюйте програму в Ардуїно, завантажте нашу нову програму на Дрон

Підказка: якщо пищалка набридне, щоб вберегти свої нерви і зупинити пищалку переведіть Дрон в режим програмування уже знайомим способом. Так мелодія зупиниться

Самостійна робота №1

Спробуйте модифікувати попередній приклад, змінивши частоту на будь-яку іншу, тривалість пищання чи павзи між пищаннями. Поспостерігайте за змінами в тональності, особливо між високими частотами (наприклад 10000 Гц) та низькими (100 Гц). Також, якщо маєте пса, спробуйте задати дуже високу частоту (10 000 Гц) і дати псу послухати. Чи змінилась поведінка пса?

Мелодії

Тепер давайте спробуємо зіграти мелодії на зумері. Якщо в попередньому прикладі ми використовували одну ноту (звучання однієї частоти), то для відомої мелодії доведеться відтворити набагато більше нот і ще й різної частоти

​
 1int buzzer = PA6;
 2
 3void setup() {
 4  pinMode(buzzer, OUTPUT);
 5}
 6
 7void loop() {
 8  tone(buzzer, 494, 800);
 9  delay(900);
10  
11  tone(buzzer, 494, 250);
12  delay(300);
13  
14  tone(buzzer, 494, 250);
15  delay(300);
16  
17  tone(buzzer, 440, 250);
18  delay(300);
19  
20  tone(buzzer, 494, 250);
21  delay(300);
22  
23  tone(buzzer, 523, 250);
24  delay(300);
25  
26  tone(buzzer, 587, 850);
27  delay(900);
28  
29  tone(buzzer, 523, 250);
30  delay(300);
31  
32  tone(buzzer, 494, 550);
33  delay(600);
34  
35  tone(buzzer, 440, 550);
36  delay(600);
37  
38  tone(buzzer, 392, 550);
39  delay(600);
40  
41  tone(buzzer, 494, 550);
42  delay(600);
43
44  tone(buzzer, 370, 550);
45  delay(600);
46  
47  tone(buzzer, 494, 550);
48  delay(1000);
49}

Завантажте цю програму на Дрон. Що за музика грає? Як бачите поєднання кількох нот різної частоти, різних за тривалістю і павзами між ними призводить до звучання знайомих мелодій. Так і створюється музика

Цикли

Єдиний недолік програми вище в тому, що ми відтворили лише невеликий уривок мелодії, а програма вже стала дуже довгою і складною для читання. Щоб це виправити нам потрібно познайомитися з такими поняттями в програмуванні як цикли і масиви. З поняттям циклів ми вже трохи знайомі по функції loop, яка сама по собі виконується циклічно: після відпрацювання всіх функцій всередині loop вони починають викликатися заново одна за одною. Це ви могли спостерігати по мелодії Гімну з програми вище: після закінчення уривку Гімну уривок починався знову. Але тепер нам треба навчитися створювати власні зациклені ділянки програми всередині loop. Давайте зіграємо всього 5 нот в циклі, щоб зрозуміти принцип роботи:

​
 1void setup() {
 2  pinMode(PA6, OUTPUT);
 3}
 4
 5void loop() {
 6  for (int i = 0; i < 5; i++) {
 7    int note = 1200 + 200 * i;
 8    tone(PA6, note, 200);
 9    delay(300);
10  }
11}
 1void setup() {
 2  pinMode(PA6, OUTPUT);         //Переводимо пін PA6 в режим роботи на ВИХІД
 3}
 4
 5void loop() {
 6  for (int i = 0; i < 5; i++) { //Оголошуємо цикл, який виконується 5 разів
 7    int note = 1200 + 200 * i;  //в кожній з 5-ти ітерацій збільшуємо ноту 1200 на 200
 8    tone(PA6, note, 200);       //відтворюємо ноти з фіксованою тривалістю 200 мілісекунд
 9    delay(300);                 //чекаємо наприклад 300 мілісекунд до відтворення наступної ноти
10  }
11}

Завантажте програму на Дрон. Як видно з прикладу вище ключове слово для створення циклу це for. Далі в круглих дужках перечислюються параметри циклу: відлік будемо починати з нуля, лічити будемо до 5 і щоразу збільшувати змінну i на одиницю. Далі в фігурних дужках розміщується тіло циклу, в якому власне написані функції, які мають виконуватися кожну ітерацію (повторення). Використовуючи змінну i ми можемо для кожної з 5-ти ітерацій використати власну ноту, давайте розпишемо в словах, що відбувається на кожній з 5-ти ітерацій:

  1. В першій ітерації i дорівнює 0, отже в змінну note запишеться 1200 (1200+200*0)
  2. В другій ітерації i вже 1, тому в змінну note запишеться 1400 (1200+200*1)
  3. В третій ітерації i збільшилась вже до 2, тому в змінну note запишеться 1600 (1200+200*2)
  4. В четвертій ітерації i збільшилась до 3, тому в змінну note запишеться 1800 (1200+200*3)
  5. В наступній ітерації i збільшилась до 4, тому в змінну note запишеться 2000 (1200+200*4)
  6. Наступна ітерація не відбудеться, тому що ми задали щоб цикл виконувався допоки змінна i менша за 5, а змінна вже досягла значення 4. І при збільшенні її до 5 вважається причиною, щоб закінчити виконання циклу.

Тобто рахуючи від 0 до 4 ми маємо 5 ітерацій, в кожній з яких змінна i має такі 5 значень: 0, 1, 2, 3, 4

Самостійна робота №2
​

Модифікуйте програму вище, щоб цикл виконувався не 5, а більше разів, наприклад 10, 15 або 20. Завантажте програму на Дрон. Щойно Ви могли відчути переваги використання циклів: замість того, щоб писати функцію tone 10, 15 чи 20 разів Ви просто змінили одне число в програмі і все.

Модифікуйте програму вище таким чином, щоб перша ітерація починалась з частоти не 1200, а наприклад 2000. І щоб збільшувалась не по 200 за ітерацію, а по 500.

Масиви

Цикли найчастіше застосовують з масивами. Масиви це набір змінних одного типу. Тобто якщо раніше ми створювали одну змінну за раз, то тепер зможемо створювати їх багато за один раз. Погляньте на програму з уривком Гімну, там дуже багато різних чисел, які було б зручно записати разом в одному місці, а потім використовувати. Для цього і будемо використовувати масиви. А от в уже в циклах зручно звертатися до елементів масиву. Це тому, що звичайні змінні мають назви, по який до них треба звертатися. Тобто якщо у Вас є наприклад 5 змінних, то треба пам’ятати назву кожної і по ній звертатися. Це складно. Елементи (змінні) в масиві не мають назв, лише сам масив має ім’я, а звертатися до елементів масиву треба по їх порядковому номеру, починаючи з нуля. Тобто достатньо порахувати до 5, щоб звернутися до кожної змінної. Давайте напишемо програму, де використаємо всього один масив і всього один цикл, з якого будемо діставати елементи з масиву.

​
 1void setup() {
 2  pinMode(PA6, OUTPUT);
 3}
 4
 5int notes[] = { 1200, 900, 1100, 1300, 2500 };
 6
 7void loop() {
 8  for (int i = 0; i < 5; i++) {
 9    int note = notes[i];
10    tone(PA6, note, 200);
11    delay(250);
12  }
13}
 1void setup() {
 2  pinMode(PA6, OUTPUT);
 3}
 4
 5int notes[] = { 1200, 900, 1100, 1300, 2500 }; //створюємо масив наприклад з 5-ти чисел типу int
 6
 7void loop() {
 8  for (int i = 0; i < 5; i++) { //створюємо цикл: рахуємо з нуля до 5 і збільшуємо змінну 'i' щоразу
 9    int note = notes[i];   //елементи в масиві не мають назв, але натомість можна звертатись по номеру
10    tone(PA6, note, 200);  //на піні PA6 відтворюємо 5 нот з масиву 'notes', кожну впродовж 200 мс
11    delay(250);            //затримка між нотами хай буде 250 мс
12  }
13}

В програмі вище ми виконали наступні дії:

  1. Створили масив notes з 5-ти нот різної частоти
  2. Створили цикл, який перебирає кожну ноту з масиву і відтворює її впродовж 200 мілісекунд
Важливо

Насправді затримка між нотами в 250 мс це не час між закінченням однієї ноти і початком наступної як могло здатися. Насправді це час між початком першої і початком наступної ноти. Тобто, якщо тривалість кожної ноти 200 мс, то виходить що реальна павза між нотами 50 мс (тобто 250 - 200). 50 мілісекунд це дуже мало і Вам може здатися, що павзи насправді немає, оскільки ноти відтворюються одна за одною дуже швидко. Насправді ж павзи є. Якщо не вірите, спробуйте поставити число значно більше за 250 мс і переконайтесь самі.

Нарешті, познайомившись з циклами, масивами і як їх разом можна використовувати давайте відтворимо більш повний Гімн України за допомогою них:

​
 1void setup() {
 2  pinMode(PA6, OUTPUT);
 3}
 4
 5int notes[] = {
 6  494, 494, 494, 440, 494, 523, 587, 523, 494,
 7  440, 392, 494, 370, 494, 330, 370, 392, 440,
 8  494, 494, 494, 440, 494, 523, 587, 523, 494,
 9  440, 392, 494, 370, 494, 330, 330, 370, 370,
10  494, 440, 392, 370, 330, 370, 392, 330, 370,
11  370, 392, 392, 440, 440, 494, 494, 370, 370,
12  494, 440, 392, 370, 330, 370, 392, 330, 370,
13  370, 392, 494, 370, 494, 330, 370, 392, 440
14};
15
16int durations[] = {
17  800, 250, 250, 250, 250, 250, 850, 250, 550,
18  550, 550, 550, 550, 550, 850, 250, 550, 550,
19  850, 250, 250, 250, 250, 250, 850, 250, 550,
20  550, 550, 550, 550, 550, 1100, 550, 850, 250,
21  250, 250, 250, 250, 250, 250, 250, 250, 550,
22  550, 550, 550, 550, 550, 1100, 550, 800, 250,
23  250, 250, 250, 250, 250, 250, 250, 250, 550,
24  550, 550, 550, 550, 550, 800, 250, 250, 250
25};
26
27int delays[] = {
28  900, 300, 300, 300, 300, 300, 900, 300, 600,
29  600, 600, 600, 600, 600, 900, 300, 600, 600,
30  900, 300, 300, 300, 300, 300, 900, 300, 600,
31  600, 600, 600, 600, 600, 1200, 1200, 900, 300,
32  300, 300, 300, 300, 300, 300, 300, 300, 600,
33  600, 600, 600, 600, 600, 1200, 1200, 900, 300,
34  300, 300, 300, 300, 300, 300, 300, 300, 600,
35  600, 600, 600, 600, 600, 900, 300, 300, 300
36};
37
38void loop() {
39  for (int i = 0; i < 72; i++) {
40    tone(PA6, notes[i], durations[i]);
41    delay(delays[i]);
42  }
43}

В ширшій версії ми створили цілих 3 масиви: масив для самих нот, масив для їх тривалості та масив для павз між ними. В кожному з масивів по 74 елементи. Тобто, щоб відтворити одну 1 ноту ми беремо частоту з першого масив, тривалість ноти з 2-го, і павзу перед наступною нотою з 3-го масиву. Важко уявити як це саме довелося писати без масивів, а лише з використанням змінних. Отже ми набагато скоротили нашу програму і при цьому Гімн зробили довшим.

Якщо хочете спробувати інші мелодії, то ось список із деяких популярних з ігор та фільмів.

Мелодії з Ігор

​
  1void setup() {
  2  pinMode(PA6, OUTPUT);
  3}
  4
  5int notes[] = {
  6  659, 659, 0, 659, 0, 523, 659, 784, 0,
  7  392, 0, 523, 392, 0, 330, 440, 494, 466,
  8  440, 392, 659, 784, 880, 698, 784, 0, 659,
  9  523, 587, 494, 523, 392, 0, 330, 440, 494,
 10  466, 440, 392, 659, 784, 880, 698, 784, 0,
 11  659, 523, 587, 494, 0, 784, 740, 698, 622,
 12  659, 0, 415, 440, 262, 0, 440, 523, 587,
 13  0, 622, 0, 587, 523, 0, 0, 784, 740,
 14  698, 622, 659, 0, 415, 440, 262, 0, 440,
 15  523, 587, 0, 622, 0, 587, 523, 0, 523,
 16  523, 523, 0, 523, 587, 659, 523, 440, 392,
 17  523, 523, 523, 0, 523, 587, 659, 0, 523,
 18  523, 523, 0, 523, 587, 659, 523, 440, 392,
 19  659, 659, 0, 659, 0, 523, 659, 784, 0,
 20  392, 0, 523, 392, 0, 330, 440, 494, 466,
 21  440, 392, 659, 784, 880, 698, 784, 0, 659,
 22  523, 587, 494, 523, 392, 0, 330, 440, 494,
 23  466, 440, 392, 659, 784, 880, 698, 784, 0,
 24  659, 523, 587, 494, 659, 523, 392, 0, 415,
 25  440, 698, 698, 440, 587, 880, 880, 880, 784,
 26  698, 659, 523, 440, 392, 659, 523, 392, 0,
 27  415, 440, 698, 698, 440, 494, 698, 698, 698,
 28  659, 587, 523, 330, 330, 262, 659, 523, 392,
 29  0, 415, 440, 698, 698, 440, 587, 880, 880,
 30  880, 784, 698, 659, 523, 440, 392, 659, 523,
 31  392, 0, 415, 440, 698, 698, 440, 494, 698,
 32  698, 698, 659, 587, 523, 330, 330, 262, 523,
 33  523, 523, 0, 523, 587, 659, 0, 523, 523,
 34  523, 0, 523, 587, 659, 523, 440, 392, 659,
 35  659, 0, 659, 0, 523, 659, 784, 0, 392,
 36  0, 659, 523, 392, 0, 415, 440, 698, 698,
 37  440, 587, 880, 880, 880, 784, 698, 659, 523,
 38  440, 392, 659, 523, 392, 0, 415, 440, 698,
 39  698, 440, 494, 698, 698, 698, 659, 587, 523,
 40  330, 330, 262, 523, 392, 330, 440, 494, 440,
 41  415, 466, 415, 392, 294, 330
 42};
 43
 44int durations[] = {
 45  125, 125, 125, 125, 125, 125, 125,
 46  250, 250, 125, 250, 250, 125, 250, 250,
 47  250, 250, 125, 250, 125, 125, 125, 250, 125, 125,
 48  125, 250, 125, 125, 250, 250, 125, 250, 250,
 49  250, 250, 125, 250, 125, 125, 125, 250, 125, 125,
 50  125, 250, 125, 125, 250,
 51  250, 125, 125, 125, 250, 125,
 52  125, 125, 125, 125, 125, 125, 125, 125,
 53  250, 250, 125, 250, 500, 500,
 54  250, 125, 125, 125, 250, 125,
 55  125, 125, 125, 125, 125, 125, 125, 125,
 56  250, 250, 125, 250, 500, 500,
 57  125, 250, 125, 125, 125, 250,
 58  125, 250, 125, 500,
 59  125, 250, 125, 125, 125, 125, 125, 1000,
 60  125, 250, 125, 125, 125, 250,
 61  125, 250, 125, 500,
 62  125, 125, 125, 125, 125, 125, 250,
 63  250, 250, 250, 250, 250, 125, 250, 250,
 64  250, 250, 125, 250,
 65  125, 125, 125, 250, 125, 125,
 66  125, 250, 125, 125, 250,
 67  250, 125, 250, 250, 250, 250, 125, 250,
 68  125, 125, 125, 250, 125, 125,
 69  125, 250, 125, 125, 250,
 70  125, 250, 125, 250, 250,
 71  125, 250, 125, 500,
 72  125, 125, 125, 125, 125, 125,
 73  125, 250, 125, 500,
 74  125, 250, 125, 250, 250,
 75  125, 250, 125, 500,
 76  125, 250, 125, 125, 125, 125,
 77  125, 250, 125, 500,
 78  125, 250, 125, 250, 250,
 79  125, 250, 125, 500,
 80  125, 125, 125, 125, 125, 125,
 81  125, 250, 125, 500,
 82  125, 250, 125, 250, 250,
 83  125, 250, 125, 500,
 84  125, 250, 125, 125, 125, 125,
 85  125, 250, 125, 500,
 86  125, 250, 125, 125, 125, 125, 125, 1000,
 87  125, 250, 125, 125, 125, 250,
 88  125, 250, 125, 500,
 89  125, 125, 125, 125, 125, 125, 250,
 90  250, 250, 250, 250,
 91  125, 250, 125, 250, 250,
 92  125, 250, 125, 500,
 93  125, 125, 125, 125, 125, 125,
 94  125, 250, 125, 500,
 95  125, 250, 125, 250, 250,
 96  125, 250, 125, 500,
 97  125, 250, 125, 125, 125, 125,
 98  125, 250, 125, 500,
 99  250, 250, 250,
100  125, 125, 125, 125, 125, 125,
101  125, 125, 500
102};
103
104int delays[] = {
105  152, 152, 152, 152, 152, 152, 152,
106  305, 305, 152, 305, 305, 152, 305, 305,
107  305, 305, 152, 305, 152, 152, 152, 305, 152, 152,
108  152, 305, 152, 152, 305,
109  305, 152, 305, 305, 305, 305, 152, 305,
110  152, 152, 152, 305, 152, 152,
111  152, 305, 152, 152, 305,
112  305, 152, 152, 152, 305, 152,
113  152, 152, 152, 152, 152, 152, 152, 152,
114  305, 305, 152, 305, 610, 610,
115  305, 152, 152, 152, 305, 152,
116  152, 152, 152, 152, 152, 152, 152, 152,
117  305, 305, 152, 305, 610, 610,
118  152, 305, 152, 152, 152, 305,
119  152, 305, 152, 610,
120  152, 305, 152, 152, 152, 152, 152,
121  1220, 152, 305, 152, 152, 152, 305,
122  152, 305, 152, 610,
123  152, 152, 152, 152, 152, 152, 305,
124  305, 305, 305, 305, 305, 152, 305, 305,
125  305, 305, 152, 305,
126  152, 152, 152, 305, 152, 152,
127  152, 305, 152, 152, 305,
128  305, 152, 305, 305, 305, 305, 152, 305,
129  152, 152, 152, 305, 152, 152,
130  152, 305, 152, 152, 305,
131  152, 305, 152, 305, 305,
132  152, 305, 152, 610,
133  152, 152, 152, 152, 152, 152,
134  152, 305, 152, 610,
135  152, 305, 152, 305, 305,
136  152, 305, 152, 610,
137  152, 305, 152, 152, 152, 152,
138  152, 305, 152, 610,
139  152, 305, 152, 305, 305,
140  152, 305, 152, 610,
141  152, 152, 152, 152, 152, 152,
142  152, 305, 152, 610,
143  152, 305, 152, 305, 305,
144  152, 305, 152, 610,
145  152, 305, 152, 152, 152, 152,
146  152, 305, 152, 610,
147  152, 305, 152, 152, 152, 152, 152,
148  1220, 152, 305, 152, 152, 152, 305,
149  152, 305, 152, 610,
150  152, 152, 152, 152, 152, 152, 305,
151  305, 305, 305, 305,
152  152, 305, 152, 305, 305,
153  152, 305, 152, 610,
154  152, 152, 152, 152, 152, 152,
155  152, 305, 152, 610,
156  152, 305, 152, 305, 305,
157  152, 305, 152, 610,
158  152, 305, 152, 152, 152, 152,
159  152, 305, 152, 610,
160  305, 305, 305, 152, 152, 152, 152, 152, 152,
161  152, 152, 610
162};
163
164void loop() {
165  for (int i = 0; i < 321; i++) {
166    tone(PA6, notes[i], durations[i]);
167    delay(delays[i]);
168  }
169}
 1void setup() {
 2  pinMode(PA6, OUTPUT);
 3}
 4
 5int notes[] = {
 6  659, 494, 523, 587, 523, 494,
 7  440, 440, 523, 659, 587, 523,
 8  494, 523, 587, 659,
 9  523, 440, 440, 440, 494, 523,
10  587, 698, 880, 784, 698,
11  659, 523, 659, 587, 523,
12  494, 494, 523, 587, 659,
13  523, 440, 440, 0,
14  659, 494, 523, 587, 523, 494,
15  440, 440, 523, 659, 587, 523,
16  494, 523, 587, 659,
17  523, 440, 440, 440, 494, 523,
18  587, 698, 880, 784, 698,
19  659, 523, 659, 587, 523,
20  494, 494, 523, 587, 659,
21  523, 440, 440, 0,
22  659, 523, 587, 494,
23  523, 440, 415, 494, 0,
24  659, 523, 587, 494,
25  523, 659, 880, 831
26};
27
28int durations[] = {
29  250, 125, 125, 250, 125, 125,
30  250, 125, 125, 250, 125, 125,
31  250, 125, 250, 250,
32  250, 250, 125, 250, 125, 125,
33  250, 125, 250, 125, 125,
34  250, 125, 250, 125, 125,
35  250, 125, 125, 250, 250,
36  250, 250, 250, 250,
37  250, 125, 125, 250, 125, 125,
38  250, 125, 125, 250, 125, 125,
39  250, 125, 250, 250,
40  250, 250, 125, 250, 125, 125,
41  250, 125, 250, 125, 125,
42  250, 125, 250, 125, 125,
43  250, 125, 125, 250, 250,
44  250, 250, 250, 250,
45  500, 500, 500, 500,
46  500, 500, 500, 250, 125,
47  500, 500, 500, 500,
48  250, 250, 500, 500
49};
50
51int delays[] = {
52  350, 175, 175, 350, 175, 175,
53  350, 175, 175, 350, 175, 175,
54  350, 175, 350, 350,
55  350, 350, 175, 350, 175, 175,
56  350, 175, 350, 175, 175,
57  350, 175, 350, 175, 175,
58  350, 175, 175, 350, 350,
59  350, 350, 350, 350,
60  350, 175, 175, 350, 175, 175,
61  350, 175, 175, 350, 175, 175,
62  350, 175, 350, 350,
63  350, 350, 175, 350, 175, 175,
64  350, 175, 350, 175, 175,
65  350, 175, 350, 175, 175,
66  350, 175, 175, 350, 350,
67  350, 350, 350, 350,
68  700, 700, 700, 700,
69  700, 700, 700, 350, 175,
70  700, 700, 700, 700,
71  350, 350, 700, 700
72};
73
74void loop() {
75  for (int i = 0; i < 99; i++) {
76    tone(PA6, notes[i], durations[i]);
77    delay(delays[i]);
78  }
79}
  1void setup() {
  2  pinMode(PA6, OUTPUT);
  3}
  4
  5int notes[] = {
  6  82, 82, 165, 82, 82, 147, 82, 82,
  7  131, 82, 82, 117, 82, 82, 123, 131,
  8  82, 82, 165, 82, 82, 147, 82, 82,
  9  131, 82, 82, 117,
 10
 11  82, 82, 165, 82, 82, 147, 82, 82,
 12  131, 82, 82, 117, 82, 82, 123, 131,
 13  82, 82, 165, 82, 82, 147, 82, 82,
 14  131, 82, 82, 117,
 15
 16  82, 82, 165, 82, 82, 147, 82, 82,
 17  131, 82, 82, 117, 82, 82, 123, 131,
 18  82, 82, 165, 82, 82, 147, 82, 82,
 19  131, 82, 82, 117,
 20
 21  82, 82, 165, 82, 82, 147, 82, 82,
 22  131, 82, 82, 117, 82, 82, 123, 131,
 23  82, 82, 165, 82, 82, 147, 82, 82,
 24  185, 147, 123, 220, 185, 123, 147, 185, 220, 185, 147, 123,
 25
 26  82, 82, 165, 82, 82, 147, 82, 82,
 27  131, 82, 82, 117, 82, 82, 123, 131,
 28  82, 82, 165, 82, 82, 147, 82, 82,
 29  131, 82, 82, 117,
 30
 31  82, 82, 165, 82, 82, 147, 82, 82,
 32  131, 82, 82, 117, 82, 82, 123, 131,
 33  82, 82, 165, 82, 82, 147, 82, 82,
 34  247, 196, 165, 196, 247, 330, 196, 247, 330, 247, 392, 494,
 35
 36  110, 110, 220, 110, 110, 196, 110, 110,
 37  175, 110, 110, 156, 110, 110, 165, 175,
 38  110, 110, 220, 110, 110, 196, 110, 110,
 39  175, 110, 110, 156,
 40
 41  110, 110, 220, 110, 110, 196, 110, 110,
 42  175, 110, 110, 156, 110, 110, 165, 175,
 43  110, 110, 220, 110, 110, 196, 110, 110,
 44  220, 175, 147, 220, 175, 147, 262, 220, 175, 220, 175, 147,
 45
 46  82, 82, 165, 82, 82, 147, 82, 82,
 47  131, 82, 82, 117, 82, 82, 123, 131,
 48  82, 82, 165, 82, 82, 147, 82, 82,
 49  131, 82, 82, 117,
 50
 51  82, 82, 165, 82, 82, 147, 82, 82,
 52  131, 82, 82, 117, 82, 82, 123, 131,
 53  82, 82, 165, 82, 82, 147, 82, 82,
 54  131, 82, 82, 117,
 55
 56  139, 139, 277, 139, 139, 247, 139, 139,
 57  220, 139, 139, 196, 139, 139, 208, 220,
 58  123, 123, 247, 123, 123, 220, 123, 123,
 59  196, 123, 123, 175,
 60
 61  82, 82, 165, 82, 82, 147, 82, 82,
 62  131, 82, 82, 117, 82, 82, 123, 131,
 63  82, 82, 165, 82, 82, 147, 82, 82,
 64  247, 196, 165, 196, 247, 330, 196, 247, 330, 247, 392, 494,
 65
 66  82, 82, 165, 82, 82, 147, 82, 82,
 67  131, 82, 82, 117, 82, 82, 123, 131,
 68  82, 82, 165, 82, 82, 147, 82, 82,
 69  131, 82, 82, 117,
 70
 71  82, 82, 165, 82, 82, 147, 82, 82,
 72  131, 82, 82, 117, 82, 82, 123, 131,
 73  82, 82, 165, 82, 82, 147, 82, 82,
 74  185, 156, 123, 185, 156, 123, 196, 147, 123, 311, 156, 123,
 75
 76  82, 82, 165, 82, 82, 147, 82, 82,
 77  131, 82, 82, 117, 82, 82, 123, 131,
 78  82, 82, 165, 82, 82, 147, 82, 82,
 79  131, 82, 82, 117,
 80
 81  82, 82, 165, 82, 82, 147, 82, 82,
 82  131, 82, 82, 117, 82, 82, 123, 131,
 83  82, 82, 165, 82, 82, 147, 82, 82,
 84  330, 247, 196, 392, 330, 196, 247, 294, 330, 392, 330, 196,
 85
 86  82, 82, 165, 82, 82, 147, 82, 82,
 87  131, 82, 82, 117, 82, 82, 123, 131,
 88  82, 82, 165, 82, 82, 147, 82, 82,
 89  131, 82, 82, 117,
 90
 91  110, 110, 220, 110, 110, 196, 110, 110,
 92  175, 110, 110, 156, 110, 110, 165, 175,
 93  110, 110, 220, 110, 110, 196, 110, 110,
 94  220, 175, 147, 220, 175, 147, 262, 220, 175, 220, 175, 147,
 95
 96  82, 82, 165, 82, 82, 147, 82, 82,
 97  131, 82, 82, 117, 82, 82, 123, 131,
 98  82, 82, 165, 82, 82, 147, 82, 82,
 99  131, 82, 82, 117
100};
101
102int durations[] = {
103  125, 125, 125, 125, 125, 125, 125, 125,
104  125, 125, 125, 125, 125, 125, 125, 125,
105  125, 125, 125, 125, 125, 125, 125, 125,
106  125, 125, 125, 500,
107  125, 125, 125, 125, 125, 125, 125, 125,
108  125, 125, 125, 125, 125, 125, 125, 125,
109  125, 125, 125, 125, 125, 125, 125, 125,
110  125, 125, 125, 500,
111  125, 125, 125, 125, 125, 125, 125, 125,
112  125, 125, 125, 125, 125, 125, 125, 125,
113  125, 125, 125, 125, 125, 125, 125, 125,
114  125, 125, 125, 500,
115  125, 125, 125, 125, 125, 125, 125, 125,
116  125, 125, 125, 125, 125, 125, 125, 125,
117  125, 125, 125, 125, 125, 125, 125, 125,
118  63, 63, 63, 63, 63, 63, 63, 63, 63, 63, 63, 63,
119  125, 125, 125, 125, 125, 125, 125, 125,
120  125, 125, 125, 125, 125, 125, 125, 125,
121  125, 125, 125, 125, 125, 125, 125, 125,
122  125, 125, 125, 500,
123  125, 125, 125, 125, 125, 125, 125, 125,
124  125, 125, 125, 125, 125, 125, 125, 125,
125  125, 125, 125, 125, 125, 125, 125, 125,
126  63, 63, 63, 63, 63, 63, 63, 63, 63, 63, 63, 63,
127  125, 125, 125, 125, 125, 125, 125, 125,
128  125, 125, 125, 125, 125, 125, 125, 125,
129  125, 125, 125, 125, 125, 125, 125, 125,
130  125, 125, 125, 500,
131  125, 125, 125, 125, 125, 125, 125, 125,
132  125, 125, 125, 125, 125, 125, 125, 125,
133  125, 125, 125, 125, 125, 125, 125, 125,
134  63, 63, 63, 63, 63, 63, 63, 63, 63, 63, 63, 63,
135  125, 125, 125, 125, 125, 125, 125, 125,
136  125, 125, 125, 125, 125, 125, 125, 125,
137  125, 125, 125, 125, 125, 125, 125, 125,
138  125, 125, 125, 500,
139  125, 125, 125, 125, 125, 125, 125, 125,
140  125, 125, 125, 125, 125, 125, 125, 125,
141  125, 125, 125, 125, 125, 125, 125, 125,
142  125, 125, 125, 500,
143  125, 125, 125, 125, 125, 125, 125, 125,
144  125, 125, 125, 125, 125, 125, 125, 125,
145  125, 125, 125, 125, 125, 125, 125, 125,
146  125, 125, 125, 500,
147  125, 125, 125, 125, 125, 125, 125, 125,
148  125, 125, 125, 125, 125, 125, 125, 125,
149  125, 125, 125, 125, 125, 125, 125, 125,
150  63, 63, 63, 63, 63, 63, 63, 63, 63, 63, 63, 63,
151  125, 125, 125, 125, 125, 125, 125, 125,
152  125, 125, 125, 125, 125, 125, 125, 125,
153  125, 125, 125, 125, 125, 125, 125, 125,
154  125, 125, 125, 500,
155  125, 125, 125, 125, 125, 125, 125, 125,
156  125, 125, 125, 125, 125, 125, 125, 125,
157  125, 125, 125, 125, 125, 125, 125, 125,
158  63, 63, 63, 63, 63, 63, 63, 63, 63, 63, 63, 63,
159  125, 125, 125, 125, 125, 125, 125, 125,
160  125, 125, 125, 125, 125, 125, 125, 125,
161  125, 125, 125, 125, 125, 125, 125, 125,
162  125, 125, 125, 500,
163  125, 125, 125, 125, 125, 125, 125, 125,
164  125, 125, 125, 125, 125, 125, 125, 125,
165  125, 125, 125, 125, 125, 125, 125, 125,
166  63, 63, 63, 63, 63, 63, 63, 63, 63, 63, 63, 63,
167  125, 125, 125, 125, 125, 125, 125, 125,
168  125, 125, 125, 125, 125, 125, 125, 125,
169  125, 125, 125, 125, 125, 125, 125, 125,
170  125, 125, 125, 500,
171  125, 125, 125, 125, 125, 125, 125, 125,
172  125, 125, 125, 125, 125, 125, 125, 125,
173  125, 125, 125, 125, 125, 125, 125, 125,
174  63, 63, 63, 63, 63, 63, 63, 63, 63, 63, 63, 63,
175  125, 125, 125, 125, 125, 125, 125, 125,
176  125, 125, 125, 125, 125, 125, 125, 125,
177  125, 125, 125, 125, 125, 125, 125, 125,
178  125, 125, 125, 500
179};
180
181void loop() {
182  for (int i = 0; i < 588; i++) {
183    tone(PA6, notes[i], durations[i]);
184    delay(durations[i] * 1.3);
185  }
186}
 1void setup() {
 2  pinMode(PA6, OUTPUT);
 3}
 4
 5int notes[] = {
 6  494, 988, 740, 622,
 7  988, 740, 622, 523,
 8  1047, 1568, 1319, 1047, 1568, 1319,
 9  494, 988, 740, 622, 988,
10  740, 622, 622, 659, 698,
11  698, 740, 784, 784, 831, 880, 988
12};
13
14int durations[] = {
15  63, 63, 63, 63,
16  32, 63, 125, 63,
17  63, 63, 63, 32, 63, 125,
18  63, 63, 63, 63, 32,
19  63, 125, 32, 32, 32,
20  32, 32, 32, 32, 32, 63, 125
21};
22
23void loop() {
24  for (int i = 0; i < 31; i++) {
25    tone(PA6, notes[i], durations[i]);
26    delay(durations[i] * 2.5);
27  }
28}

Мелодії з Фільмів

​
 1void setup() {
 2  pinMode(PA6, OUTPUT);
 3}
 4
 5int notes[] = {
 6  330, 392, 440, 440, 0, 440, 494, 523, 523, 0,
 7  523, 587, 494, 494, 0, 440, 392, 440, 0, 330,
 8  392, 440, 440, 0, 440, 494, 523, 523, 0, 523,
 9  587, 494, 494, 0, 440, 392, 440, 0, 330, 392,
10  440, 440, 0, 440, 523, 587, 587, 0, 587, 659,
11  698, 698, 0, 659, 587, 659, 440, 0, 440, 494,
12  523, 523, 0, 587, 659, 440, 0, 440, 523, 494,
13  494, 0, 523, 440, 494, 0, 440, 440, 440, 494,
14  523, 523, 0, 523, 587, 494, 494, 0, 440, 392,
15  440, 0, 330, 392, 440, 440, 0, 440, 494, 523,
16  523, 0, 523, 587, 494, 494, 0, 440, 392, 440,
17  0, 330, 392, 440, 440, 0, 440, 523, 587, 587,
18  0, 587, 659, 698, 698, 0, 659, 587, 659, 440,
19  0, 440, 494, 523, 523, 0, 587, 659, 440, 0,
20  440, 523, 494, 494, 0, 523, 440, 494, 0, 659,
21  0, 0, 698, 0, 0, 659, 659, 0, 784, 0, 659, 587,
22  0, 0, 587, 0, 0, 523, 0, 0, 494, 523, 0, 494,
23  0, 440, 659, 0, 0, 698, 0, 0, 659, 659, 0,
24  784, 0, 659, 587, 0, 0, 587, 0, 0, 523, 0, 0,
25  494, 523, 0, 494, 0, 440
26};
27
28
29int durations[] = {
30  125, 125, 250, 125, 125, 125, 125, 250, 125, 125,
31  125, 125, 250, 125, 125, 125, 125, 250, 125,
32  125, 125, 250, 125, 125, 125, 125, 250, 125, 125,
33  125, 125, 250, 125, 125, 125, 125, 250, 125,
34  125, 125, 250, 125, 125, 125, 125, 250, 125, 125,
35  125, 125, 250, 125, 125, 125, 125, 125, 250, 125,
36  125, 125, 250, 125, 125, 250, 125, 250, 125,
37  125, 125, 250, 125, 125, 125, 125, 250, 250,
38  250, 125, 125, 125, 250, 125, 125, 125, 125, 250, 125, 125,
39  125, 125, 250, 125, 125, 125, 250, 125, 125,
40  125, 125, 250, 125, 125, 125, 125, 250, 125, 125,
41  125, 125, 250, 125, 125, 125, 250, 125, 125,
42  125, 125, 250, 125, 125, 125, 125, 250, 125, 125,
43  125, 125, 125, 250, 125, 125, 125, 250, 125, 125,
44  250, 125, 250, 125, 125, 125, 250, 125, 125,
45  125, 125, 250, 250, 250, 125, 250, 250, 125, 250,
46  125, 125, 125, 125, 125, 125, 125, 125, 250,
47  250, 125, 250, 250, 125, 250, 125, 125, 125, 125, 125, 500,
48  250, 125, 250, 250, 125, 250, 125, 125, 125,
49  125, 125, 125, 125, 125, 250, 250, 125, 250,
50  250, 125, 250, 125, 125, 125, 125, 125, 500
51};
52
53int delays[] = {
54  162, 162, 325, 162, 162, 162, 162, 325, 162, 162,
55  162, 162, 325, 162, 162, 162, 162, 325, 162,
56  162, 162, 325, 162, 162, 162, 162, 325, 162, 162,
57  162, 162, 325, 162, 162, 162, 162, 325, 162,
58  162, 162, 325, 162, 162, 162, 162, 325, 162, 162,
59  162, 162, 325, 162, 162, 162, 162, 162, 325, 162,
60  162, 162, 325, 162, 162, 325, 162, 325, 162,
61  162, 162, 325, 162, 162, 162, 162, 325, 325,
62  325, 162, 162, 162, 325, 162, 162,
63  162, 162, 325, 162, 162, 162, 162, 325, 162,
64  162, 162, 325, 162, 162, 162, 162, 325, 162, 162,
65  162, 162, 325, 162, 162, 162, 162, 325, 162,
66  162, 162, 325, 162, 162, 162, 162, 325, 162, 162,
67  162, 162, 325, 162, 162, 162, 162, 162, 325, 162,
68  162, 162, 325, 162, 162, 325, 162, 325, 162,
69  162, 162, 325, 162, 162, 162, 162, 325, 325,
70  325, 162, 325, 325, 162, 325, 162, 162, 162,
71  162, 162, 162, 162, 162, 325, 325, 162, 325, 325, 162, 325,
72  162, 162, 162, 162, 162, 650, 325, 162, 325, 325, 162, 325,
73  162, 162, 162, 162, 162, 162, 162, 162, 325,
74  325, 162, 325, 325, 162, 325, 162, 162, 162, 162, 162, 650
75};
76
77void loop() {
78  for (int i = 0; i < 203; i++) {
79    tone(PA6, notes[i], durations[i]);
80    delay(delays[i]);
81  }
82}
 1void setup() {
 2  pinMode(PA6, OUTPUT);
 3}
 4
 5int notes[] = {
 6  466, 466, 466, 349, 1047, 880, 830, 784,
 7  1397, 1047, 880, 830, 784, 1397, 1047, 880,
 8  830, 880, 784, 523, 523, 523, 349, 1047,
 9  880, 830, 784, 1397, 1047, 880, 830, 784
10};
11
12int durations[] = {
13  125, 125, 125, 500, 500, 125, 125, 125,
14  500, 250, 125, 125, 125, 500, 250, 125,
15  125, 125, 500, 125, 125, 125, 500, 500,
16  125, 125, 125, 500, 250, 125, 125, 125
17};
18
19int delays[] = {
20  162, 162, 162, 650, 650, 162, 162, 162,
21  650, 325, 162, 162, 162, 650, 325, 162,
22  162, 162, 650, 163, 162, 163, 650, 650,
23  162, 162, 162, 650, 325, 162, 162, 162
24};
25
26void loop() {
27  for (int i = 0; i < 32; i++) {
28    tone(PA6, notes[i], durations[i]);
29    delay(delays[i]);
30  }
31}
 1void setup() {
 2  pinMode(PA6, OUTPUT);
 3}
 4
 5int notes[] = {
 6  0, 294, 392, 466, 440, 392, 587, 523, 440,
 7  392, 466, 440, 349, 415, 294, 294, 392, 466,
 8  440, 392, 587, 698, 659, 622, 494, 622, 587,
 9  554, 277, 494, 392, 466, 587, 466, 587, 466,
10  622, 587, 554, 440, 466, 587, 554, 277, 294,
11  587, 0, 466, 587, 466, 587, 466, 698, 659,
12  622, 494, 622, 587, 554, 277, 466, 392
13};
14
15int durations[] = {
16  500, 250, 250, 125, 250, 500, 250, 500, 500,
17  250, 125, 250, 500, 250, 1000, 250, 250, 125,
18  250, 500, 250, 500, 250, 500, 250, 250, 125,
19  250, 500, 250, 1000, 250, 500, 250, 500, 250,
20  500, 250, 500, 250, 250, 125, 250, 500, 250,
21  1000, 250, 250, 500, 250, 500, 250, 500, 250,
22  500, 250, 250, 125, 250, 500, 250, 1000
23};
24
25int delays[] = {
26  650, 325, 325, 162, 325, 650, 325, 650, 650,
27  325, 162, 325, 650, 325, 1300, 325, 325, 162,
28  325, 650, 325, 650, 325, 650, 325, 325, 162,
29  325, 650, 325, 1300, 325, 650, 325, 650, 325,
30  650, 325, 650, 325, 325, 162, 325, 650, 325,
31  1300, 325, 325, 650, 325, 650, 325, 650, 325,
32  650, 325, 325, 162, 325, 650, 325, 1300
33};
34
35void loop() {
36  for (int i = 0; i < 62; i++) {
37    tone(PA6, notes[i], durations[i]);
38    delay(delays[i]);
39  }
40}
 1void setup() {
 2  pinMode(PA6, OUTPUT);
 3}
 4
 5int notes[] = {
 6  392, 262, 311, 349, 392, 262, 311, 349, 392,
 7  262, 330, 349, 392, 262, 330, 349, 392, 262,
 8  330, 349, 392, 262, 330, 349, 392, 262,
 9  311, 349, 392, 262, 311, 349, 294,
10  349, 233, 311, 294, 349, 233, 311,
11  294, 262, 392, 262, 311, 349, 392, 262,
12  311, 349, 294, 349, 233, 311, 294, 349,
13  233, 311, 294, 262, 392, 262, 311, 349,
14  392, 262, 311, 349, 294, 349, 233, 294,
15  311, 294, 233, 262, 523, 466, 262,
16  392, 311, 311, 349, 392, 523, 466,
17  262, 392, 311, 311, 294, 523, 392,
18  415, 466, 523, 392, 415, 466, 523,
19  392, 415, 466, 523, 392, 415, 466,
20  0, 831, 932, 1047, 784, 831, 932
21};
22
23int durations[] = {
24  125, 125, 63, 63, 125, 125, 63, 63,
25  125, 125, 63, 63, 125, 125, 63, 63,
26  125, 125, 63, 63, 125, 125, 63, 63,
27  250, 250, 63, 63, 250, 250, 63, 63,
28  1000, 250, 250, 63, 63, 250, 250,
29  63, 63, 1000, 250, 250, 63, 63, 250,
30  250, 63, 63, 1000, 250, 250, 63, 63,
31  250, 250, 63, 63, 500, 250, 250, 125,
32  125, 125, 125, 1000, 500, 500, 500, 500,
33  500, 250, 250, 1000, 500, 500, 500, 500,
34  500, 250, 250, 125, 125, 63, 63, 125,
35  125, 63, 63, 125, 125, 63, 63, 125,
36  125, 63, 63, 250, 63, 63, 125, 125,
37  63, 63, 125, 63, 63, 63, 125, 125, 63,
38  63
39};
40
41int delays[] = {
42  225, 225, 113, 113, 225, 225, 113, 113,
43  225, 225, 113, 113, 225, 225, 113, 113,
44  225, 225, 113, 113, 225, 225, 113, 113,
45  450, 450, 113, 113, 450, 450, 113, 113,
46  1800, 450, 450, 113, 113, 450, 450,
47  113, 113, 1800, 450, 450, 113, 113, 450,
48  450, 113, 113, 1800, 450, 450, 113, 113,
49  450, 450, 113, 113, 900, 450, 450, 225,
50  225, 225, 225, 1800, 900, 900, 900, 900,
51  900, 450, 450, 1800, 900, 900, 900, 900,
52  900, 450, 450, 225, 225, 113, 113, 225,
53  225, 113, 113, 225, 225, 113, 113, 225,
54  225, 113, 113, 450, 113, 113, 225, 225,
55  113, 113, 225, 113, 113, 113, 225, 225, 113,
56  113
57};
58
59void loop() {
60  for (int i = 0; i < 113; i++) {
61    tone(PA6, notes[i], durations[i]);
62    delay(delays[i]);
63  }
64}
  • tone (тон) – тон
  • duration (дюрейшн) – тривалість
  • delay (ділей) – затримка, чекання
  • note (ноут) – нота