Arduino.ru

Что за мода пошла последнее время: никто не спрашивает "как сделать?", всех интересует исключительно "где взять?".

Вроде раньше встречалась альтернативная библиотека tone , и к ней шли примеры.

Есть ещё вариант, гораздо лучше.  Я на заре освоения мк переписал вот этот звонок с тиньки на мегу328. Там просто чудесные мелодии, всё помещается в встроенный  еепром, внешняя память не нужна.

а я наоборот, чей-то набор мелодий с Атмеги328 переписал на Тини, добавил RF433 приемник и получил музыкальный звонок :) - не тот ли самый? :)

Посмотрел рекомендуемый звонок - это не то, там нужно копаться в потрохах. Нужны мелодии для tone. Нашел: "В лесу родилась елочка" и еще пару. Неужели мелодий нет?

Я Imperial March из Star Wars как-то находил.

http://forum.amperka.ru/threads/Мелодии-для-пьезопищалки.272/page-2

Смотрел я этот форум. Снял оттуда ЕЛОЧКУ.

вот, нашел - я свой звонок делал на основе этого кода, там и мелодии есть

https://github.com/flickerfly/Music_Box

Если нужно много, сделай сам. Midi гораздо больше выбор.
Почему сами не хотите?

Огромное спасибо! Этих мелодий достаточно.

Да уж.

Я вот сейчас вспоминаю, как делал этот проект: http://arduino.ru/forum/proekty/floppy-hdd-music

Скачал из И-нета нотки (pdf) и где-то 10-15 вариантов MIDI файла желаемого произведения. Нотки распечатал и потом в них делал пометки, касающиеся отсчета времени и синхронизации.

Придумал формат, в котором описывается партия. Написал конвертер из MIDI в формат, в котором данные будут использоваться Ардуиной (т.е. в придуманный формат). Сложность заключалась в основном в том, что партитуру надо былол раскидать по 7 одноголосным каналам, при этом сами каналы обладали различными характеристиками (по тембру и воспроизводимому диапазону частот). Соответственно, придумал 4 или 5 алгоритмов преобразования фрагментов MIDI-файла в нужые мне данные (7 массивов, каждый для своего голоса). Разделил партитуру (ноты) на фрагменты, которые будут обрабатываться различными алгоритмами. Выяснил по MIDI-файлу моменты времени, в которые должны осуществляться переключения между алгоритмами (обычно один алгоритм обрабатывал несколько разделенных во времени фрагментов) и вручную прописал их в программе-конвертере.

Формат данных - массив из пар чисел: метка времени и длительность периода.

Товарищи, здавствуйте. Нужна

1. ИЛИ таблица для этой команды в варианте частота = нота. Ну и какая-то справочная информация для длительности звучания. Т.е. чтобы возможно было бы написать мелодию по нотам с соблюдением интервалов;

2. ИЛИ готовая библиотека где можно писать мелодию в виде нот. Например G 1/4 R 1/4 A 1/4 M 1/4  C 1/2 C 1/2 

Напомню, уважаемые товарищи, что здесь не школа, и учить вопрошающих не следует. Если у Вас появилось непреодолимое желание откомментировать в духе "эх какой тупой, не хочет учиться" или "Вот так вот делай" (поучать). Пожалуйста, попробуйте способ "сублимация" - подавление эмоционального напряжения через смену деятельности или физические нагрузки.

Форум - ресурс для поиска решения своей задачи. Есть ответ - пожалуйста, нет - будь мужчиной, промолчи. 

Если у Вас есть какой-то проект и готовая решенная задача, вы можете добровольно создать тему и поделиться ее решением с другими.

pickuper220 - как ты угадал реакцию на твой вопрос :) -  удивительно. какой ты тупой. Ну подглючивает сайт... нафига постить ПЯТЬ РАЗ ПОДРЯД??? с третьего раза не дошло?

Да и вопрос у тебя точно такой же. В ветке выше три или четыре примера генерации мелодий. там и отдельные ноты есть.

А учить форум, кого учить и кого нет - не надо. Сублимируй.

Вопиющий учит нас как себя вести? Аригинальна. 

Таблица умножния - подойдет?

Или нужна таблица с частотами нот?

Если последнее, то она элементарно составляется самостоятельно, исходя из известных данных:

1. Одна октава соответствует изменению частоты вдвое.

2. Строй - равномено темперированный.

3. Ля первой октавы - 440 Гц.

AlexTVR

https://www.youtube.com/watch?v=VZbZa99ocPU

По вертикали - частота. Яркое - громко, тёмное - тихо. Открываете исходник и смотрите, потом пишете цифры в tone() - вот и вся метода.

По горизонтали - время, так что если одновременно на один момент приходится несколько пиков, они генерируются с нескольких PWM выводов через резисторы на один динамик - в общем способом, аналогичным DTMF.

Кривокод ... А глядя на содержимое массива - не пришло в голову сделать два байта - нота и длительность ?

Я начинающий...   :-)

Ну хоть один!!!!

Сережа! Это как глоток воздуха! Я так давно хотел в этой теме вот именно это написать, но ты меня опередил.

Нет. Форум - место общения по интересам. К примеру ты - нахрен никому не интересен оказался. Вот только я и ответил. Ты рад? Если нет - будь мужчиной - сгинь отсюда.

Усовершенствовал. Марш "Прощание славянки"

Тихая ночь

int dat=114; //количество нот в мелодии
 
void setup() {
 
 int  melody[dat][2] = {  
87,6,78,2,87,4,104,12,87,6,78,2,87,4,104,12,58,7,1,1,
58,4,69,12,65,7,1,1,65,4,87,12,78,3,1,1,78,3,1,1,
78,4,65,6,69,2,78,4,87,6,78,2,87,4,104,12,78,3,1,1,
78,3,1,1,78,4,65,6,69,2,78,4,87,6,78,2,87,4,104,12,
58,3,1,1,58,3,1,1,58,4,49,6,58,2,69,4,65,12,52,12,
65,6,87,2,104,4,87,6,98,2,116,4,131,18
 
};
 
  for (int thisNote = 0; thisNote <dat; thisNote++) {
 
 if ( melody[thisNote][0]== 1)  // Если пауза между нотами то выключать звук
 
{
noTone(8); 
delay(125*melody[thisNote][1]);
}else{
 
    tone(8,30472/ melody[thisNote][0]);
   delay(125*melody[thisNote][1]);
 
}
 
 }  
 
 }
 
void loop() {
 
   noTone(8);
 
}

Я фигею от такой упертости:

    tone(8,30472/ melody[thisNote][0]);
 

Ну сказано же: ноты - фальшивые.

Чтобы были не фальшивые, нужно:

[/quote]

Ну сказано же: ноты - фальшивые.

[/quote]

В программном коде числа: 87, 78. 104 и т.д. задают не частоту тона, а являются коэффициентами деления опорной частоты 30472 гц, в результате которого (деления) получается частота, соответствующая определенной ноте. Например: 30472гц./87=350,25 гц (ФА первой октавы =349гц). 30472гц/78=390,66гц (СОЛЬ певой октавы =392 гц). 30472гц/104=293гц (РЕ первой октавы=293гц.) и т.д. На слух улавливаете разницу в частоте нот в 2 гц? Весьма похвально!

Можно было бы записать непосредственно частоту, как вы предложили. Но такой формат записи как у меня обусловлен тем, что мое знакомство с Ардуино началось с желания изготовить дверной звонок на новой элементной базе. Я "распотрошил" дверной звонок с мелодиями, который проработал у меня около 30 лет. Там мелодии были "зашиты" в микросхему 573РФ2. Восьмиразрядные данные не позволяли записывать число большее 255. Частота делилась аппаратно реверсивными счетчиками. Эти цифры по инерции и были перенесены на новые мелодии.

А зачем постоянно делить, если можно сразу в массиве держать частоты?

Слух улавливает разницу в частоте 0.2%. А 2 Гц от 392 Гц это более 0.5%.

И, кстати, мы работаем на Си, поэтому 30472гц/78 будет равно не 390.66, а 390 ровно. Если об этом забывать, максимальная погрешность при расчете увеличится вдвое.

Ну, в общем-то, возможности Ардуино несколько превосходят возможности дискретной логики. И тупо переносить решения, обусловленные ограничениями 30-летней давности, на современную схемотехнику вряд ли целесообразно. На мой взгляд, если уж что-то делать (а тем более - советовать другим), то решение должно быть либо заведомо приемлемым (те самые 0.2%), либо, по меньшей мере, максимально близким к приемлемому (ну, например, 0.25% при частоте ноты порядка 200 Гц, т.к. при "целой" частоте лучше сделать невозможно). А предлагать решения заведомо хуже простейшего варианта, в котором частота сразу записывается в массив и вообще ни на что не делится, - нонсенс.

Привет всем . С Наступившим.

Чего то заклинило, не знаю куда двигаться. Нашел подходящий мне скетч, хороший функционал. Чего мне не достает как всунуть туда многозвучнные аккорды. проверил- звук хорошо смешивается на динамиках через обычные сопротивления. 4 выхода достаточно для любых муз. фрагментов. Как переделать программу- я в стопоре (может новый год еще не выветрился) надо меня немного подтолкнуть!!!

[code]
/* Функция Qb_PLAY проигрывает музыку из символьных строк стандарта АВС
аналогично оператору QBASIC PLAY
http://ru.wikipedia.org/wiki/ABC_(%D0%BD%D0%BE%D1%82%D0%BD%D0%B0%D1%8F_%D0%B7%D0%B0%D0%BF%D0%B8%D1%81%D1%8C)
Горкавчук Константин.
mailto:kgg0@bk.ru
http://gorkavchukkg.narod.ru
*/
//Нота	0     1     2     3     4    5     6     7    8   	9	   10     11
//Нота	C     C#/D-	D     D#/E-	E    F     F#/G- G    G#/A- A	   A#/B-  B
int freq[7][12] = {
       {65,   69,    73,  78,   82,  87,   92,   98,   104, 110,  117,  123},  //0 = Большая октава   
       {131,  139,   147, 156,  165, 175,  185,  196,  208, 220,  233,  247},  //1 = Малая октава
       {262,  277,   294, 311,  330, 349,  370,  392,  415, 440,  466,  494},  //2 = 1-я октава
       {523,  554,   587, 622,  659, 698,  740,  784,  831, 880,  932,  988},  //3 = 2-я октава
       {1047, 1109,  1175,1245, 1319,1397, 1480, 1568, 1661,1760, 1865, 1976}, //4 = 3-я октава
       {2093, 2218,  2349,2489, 2637,2794, 2960, 3136, 3322,3520, 3729, 3951}, //5 = 4-я октава
       {4186, 4435,  4699,4978, 5274,5588, 5920, 6272, 6645,7040, 7459, 7902}, //6 = 5-я октава
};
int SoundPin1=9;
int SoundPin2=10;
int SoundPin3=11;
int SoundPin4=12;

void setup() {
  pinMode(SoundPin1, OUTPUT);
   pinMode(SoundPin2, OUTPUT);
    pinMode(SoundPin3, OUTPUT);
     pinMode(SoundPin4, OUTPUT);
  Serial.begin(9600);  
}

int extractNumber(int& myNumber, char Muz[], int& curPosition)
{
    int digitsNumber=0;
    int curDigit=0;
    myNumber=0;
    do
    {
        if ((Muz[curPosition]> 47) && (Muz[curPosition]<58)) // Коды ASCII цифр '0' == 48 , "9' == 57
        { 
            curDigit=Muz[curPosition]-48;
            digitsNumber++;
            myNumber=myNumber*10+curDigit;
        }
        else
        {
        return digitsNumber;
        }     
        curPosition++;
    }while(Muz[curPosition]!= '\0');
    return digitsNumber;
}

int pointsCount(char Muz[], int& curPosition)
{
    int pointsNumber=0;
    do
    {
        if (Muz[curPosition]== '.')
        { 
            pointsNumber++;
        }
        else
        {
        return pointsNumber;
        }     
        curPosition++;
    }while(Muz[curPosition]!= '\0');
    return pointsNumber;
}

void Qb_PLAY(char Muz[])
{
  static int generalOktava;   
  int oktava;   
  static int tempo=120; // Задание темпа или четвертных нот, которые исполняются в минуту. n от 32 до 255. По умолчанию 120
  int Nota=0; 
  int  curPosition, curNota4;
  unsigned long currentNotaPauseDuration;
  unsigned long currentNotaDuration; 
  unsigned long  pauseDuration; 
  int takt=240000/tempo; 
  bool isNota; 
  bool isPause; 
  int pointsNum=0;
  float generalNotaMultipl=0.875;
  static float NotaLong;
  float curMultipl;
  float tempFlo;
  float curPause;
  unsigned long tempLong;
  int i=0;
  do 
  {
   isNota=false; 
   isPause=false; 
   oktava=generalOktava;
   switch(Muz[i]){
         case '\0':{
             return; 
             }
             break;
         case 'C':{
             Nota=0;
             isNota=true; 
             }
             break;
         case 'D':{
             Nota=2;
             isNota=true; 
             }
             break;
         case 'E':{
             Nota=4;
             isNota=true;      
             }
             break;
         case 'F':{
             Nota=5;
             isNota=true;     
             }
             break;
         case 'G':{
             Nota=7;
             isNota=true;         
             }
             break;
         case 'A':{
             Nota=9;
             isNota=true;
             }
             break;
         case 'B':{
             Nota=11;
             isNota=true; 
             }
             break;   
         case 'N':{// Nнота	Играет определенную ноту (0 - 84) в диапазоне семи октав (0 - пауза).     
                 curPosition=i+1;
                 if (extractNumber(curNota4, Muz, curPosition)){
                     i=curPosition-1;
                     if (curNota4){
                         curNota4--;          
                         oktava=curNota4 / 12;                
                         Nota=curNota4 % 12;
                         isNota=true; 
                     }        
                     else{
                         isPause=true;
                     }
                 }                
             }
             break;   
         case 'O':{ //Oоктава	Задает текущую октаву (0 - 6). 
             curPosition=i+1;
             if (extractNumber(oktava, Muz, curPosition)){
                 i=curPosition-1;
                 generalOktava=oktava; 
                 }
             }
             break;          
         case '>':{
             generalOktava++;
             }
             break;  
         case '<':{
             generalOktava--;
             }
             break;
         case 'M':{   
              switch(Muz[i+1]){
                 case 'N':{ //MN	Нормаль. Каждая нота звучит 7/8 времени, заданного в команде L
                     generalNotaMultipl=0.875; //  =7/8
                     i++;
                     }
                     break;
                 case 'L':{ //ML	Легато. Каждая нота звучит полный интервал времени, заданного в команде L
                     generalNotaMultipl=1.0;
                     i++;
                     }
                     break;                 
                 case 'S':{ //MS	Стаккато. Каждая нота звучит 3/4 времени, заданного в команде L
                     generalNotaMultipl=0.75;  // =3/4
                     i++;
                     }
                     break;                 
                 case 'F':{ //MF Режим непосредственного исполнения. Т.е. на время проигрывания ноты программа приостанавливается. Используется по умолчанию
                     i++;   //Сдвигаем точку чтения и ничего не делаем.
                     }
                     break;   

                 case 'B':{ //MB проигрывние в буффер
                     i++;   //Сдвигаем точку чтения и ничего не делаем.
                     }
                     break;   
               }
             }
             break;             
         case 'L':{ //Lразмер	Задает длительность каждой ноты (1 - 64). L1 - целая нота, L2 - 1/2 ноты и т.д.    
             curPosition=i+1;
             if (extractNumber(curNota4, Muz, curPosition)){
                 i=curPosition-1;
                 tempFlo=float(curNota4);
                 NotaLong=1/tempFlo;
                 }             
             }
             break;
         case 'T':{ //Tтемп	Задает темп исполнения в четвертях в минуту (32-255).По умолчанию 120
             curPosition=i+1;
             if (extractNumber(tempo, Muz, curPosition)){
                i=curPosition-1;
                takt=240000/tempo; // миллисекунд на 1 целую ноту. 240000= 60 сек * 1000 мсек/сек *4 четвертей в ноте
                }             
             }
             break;
         case 'P':{ //Pпауза	Задает паузу (1 - 64). P1 - пауза в целую ноту, P2 - пауза в 1/2 ноты и т.д.
             curPosition=i+1;
             if (extractNumber(curNota4, Muz, curPosition)){
                 tempFlo=float(curNota4);
                 curPause=1/tempFlo;
                 i=curPosition-1;
                 isPause=true;
                 }
             }
             break;              
         case ' ':{ //Есть в некоторых текстах. Вероятно это пауза длительностью в текущую ноту
             curPause= NotaLong;
             isPause=true;
             }
             break;  
    }          
    if (isNota){
      switch(Muz[i+1]){
         case '#':{ // диез
             Nota++;
             i++;
             }
             break;
         case '+':{ // диез
             Nota++;
             i++;
             }
             break;                 
         case '-':{ // бемоль
           Nota--;
           i++;
          }
          break;   
       }
       curPosition=i+1;
       if (extractNumber(curNota4, Muz, curPosition)){
         currentNotaDuration=takt/curNota4;
         i=curPosition-1;
         }
     }
     if (oktava<0) oktava=0; 
     if (oktava>6) oktava=6; 
     if (isNota || isPause){ 
       curPosition=i+1;
       pointsNum=pointsCount(Muz, curPosition);  
       if (pointsNum) i=curPosition-1;   
       curMultipl=1.0;                
       for (int j=1; j<=pointsNum; j++) {
          curMultipl= curMultipl * 1.5;
       }   
       currentNotaPauseDuration=(takt*NotaLong);
     } 
     if (isNota){
        curMultipl=curMultipl*generalNotaMultipl;
        currentNotaDuration= (currentNotaPauseDuration*curMultipl); 
        if (Nota<0) Nota=0; 
        if (Nota>11) Nota=11; 
        tempLong1= freq[oktava][Nota1];
        tempLong1= freq[oktava][Nota2];
        tempLong1= freq[oktava][Nota3];
        tempLong1= freq[oktava][Nota4];
        tone(SoundPin1,tempLong1,currentNotaDuration); 
        tone(SoundPin2,tempLong2,currentNotaDuration); 
        tone(SoundPin3,tempLong3,currentNotaDuration); 
        tone(SoundPin4,tempLong4,currentNotaDuration);     
        delay(currentNotaPauseDuration);
     } 
     if (isPause){
         pauseDuration=takt*curPause*curMultipl;
         delay(pauseDuration);     
     } 
    i++;          
  } while (Muz[i]!= '\0');   
}

void loop() {
// Боже царя храни

Qb_PLAY ("MLT120L2O2EAEABEL64C#FG#BC#FG#BC#FG#BC#FG#BL2EC#G#D#G#<");
//Qb_PLAY ("MNT60L4O3#<B>EG#C#<G#>AB7EAEAEBE.E");
//Qb_PLAY ("BL2BL4BBL2BL4B>D<G.L8AL1BL4>CCC.L8CL4C<BBL8BBL4BAABL2A");
//Qb_PLAY (">DL4<BBL2BL4BBL2BL4B>D<G.L8AL1BL4>CCC.L8CL4C<BBL8BBL4>D");
//Qb_PLAY ("DC<AL1G");

/*

// Jingle Bells

Qb_PLAY ("MNT255L4O2DBAGL2D.L8DDL4DBAGL2E.L4EE>C<BAL1F+L4>DDC<A");
Qb_PLAY ("L1BL4DBAGL2D.L8DDL4DBAGL2E.L4EE>C<BA>DDDDEDC<AL2G.P4L4B");
Qb_PLAY ("BL2BL4BBL2BL4B>D<G.L8AL1BL4>CCC.L8CL4C<BBL8BBL4BAABL2A");
Qb_PLAY (">DL4<BBL2BL4BBL2BL4B>D<G.L8AL1BL4>CCC.L8CL4C<BBL8BBL4>D");
Qb_PLAY ("DC<AL1G");

//  KATIUSHA

Qb_PLAY ("MST255L2O2E.L4F+L2G.L4EGGF+EL2F+L4<BP4L2>F+.L4GL2A.L4F+");
Qb_PLAY ("AAGF+L1EL2B>EDL4EDCC<BAL2BEP4>CL4<AL2B.L4GF+<B>GF+L1E");
Qb_PLAY ("L2B>EDL4EDCC<BAL2BEP4>CL4<AL2B.L4GF+<B>GF+L1E");

// Bach 1
Qb_PLAY ("MNT150L8O3AL16>C<AL8EL16AEL8CL16ECL4<AL16EA>C<ABABAG+");
Qb_PLAY ("B>D<B>C<B>C<AL8>AL16>C<AL8EL16AEL8CL16ECL4<AL16>C<BL8>C");
Qb_PLAY ("L16C<BL8>CAL16C.L32DL8C<BL16>ED+L8EL16ED+L8E>CL16<E.L32F");
Qb_PLAY ("L8ED+L16<B>EGEF+EF+ED+F+AF+GF+GF+EGED+EAED+EBED+E>C<E");
Qb_PLAY ("D+E>C<BABGF+EL8GL32F+GL16F+L4EL8AL16>C<AL8EL16AEL8CL16E");
Qb_PLAY ("CL4<AL16EA>C<ABABAG+B>D<B>C<B>C<AL8>AL16>C<AL8EL16AEL8C");
Qb_PLAY ("L16ECL4<AL16>C<BL8>CL16C<BL8>CAL16C.L32DL8C<BL16>ED+L8E");
Qb_PLAY ("L16ED+L8E>CL16<E.L32FL8ED+L16<B>EGEF+EF+ED+F+AF+GF+GF+");
Qb_PLAY ("EGED+EAED+EBED+E>C<ED+E>C<BABGF+EL8GL32F+GL16F+L4EL8E");
Qb_PLAY ("L16GEL8<BL16>E<BL8GL16BGL4EL8AG+>DC+GL16FEL8FDFL16AFL8D");
Qb_PLAY ("L16FDL8<BL16>D<BL4GL8>CL16ECDCDC<B>DFDEDEDCEC<B>CFC<B");
Qb_PLAY (">CGC<B>CAC<B>CAGFGEDCL8EL32DEL16DL4CL16EDL8EL16EDL8E>C");
Qb_PLAY ("<EL64FL8EDL16DCL8DL16DCL8DBDL64EL8DCAL16>C<AGL4F.L16A");
Qb_PLAY ("FEL4D.L16FDCL4<A+L16A+AA+AL4G+L8FEAG+>DL16C<B>C<A>CEL8A");
Qb_PLAY ("EL16DC<B>CL4<AL8>EL16GEL8<BL16>E<BL8GL16BGL4EL8AG+>DC+");
Qb_PLAY ("GL16FEL8FDFL16AFL8DL16FDL8<BL16>D<BL4GL8>CL16ECDCDC<B");
Qb_PLAY (">DFDEDEDCEC<B>CFC<B>CGC<B>CAC<B>CAGFGEDCL8EL32DEL16DL4C");
Qb_PLAY ("L16EDL8EL16EDL8E>C<EL64FL8EDL16DCL8DL16DCL8DBDL64EL8D");
Qb_PLAY ("CAL16>C<AGL4F.L16AFEL4D.L16FDCL4<A+L16A+AA+AL4G+L8FEA");
Qb_PLAY ("G+>DL16C<B>C<A>CEL8AEL16DC<B>CL4<A");

*/
/*
//REM CIRCUS/BIG-TOP
Qb_PLAY ("MNT100L32O2EL4>EL16E.L32<E>E<E>E<EL4>EL16E.L32<E>E<E>E<E>EL16<D+DC+C<B");
Qb_PLAY ("<F+>F+<F+>F+L16<FED+DC+C<BA+AG+GF+FED+L32>GL4>GL16GL32O1B>F>G<F>G<FL4>");
Qb_PLAY ("GL16GL32O1B>F>G<F>GO1B>GFG+<B>AFA+<G>BF>CO1BO3C+<F>DO1GO3D+P32E<F>FP32");
Qb_PLAY ("F+O1BO3GP32G+O1GO3AP32BO1CO4C.P32O1GO3B.P32GA+P32BO1GO3A+P32AO1CO3G+.");
Qb_PLAY ("P32O1GO3G.P32GL16F+.L32O1GO3G.P32O1CO3A.P32O1GO3G+.P32GGP32G+O1GO3GP32");
Qb_PLAY ("F+O1CO3F.P32O1GO3E.P32GL16D+.L32O1GO3E.P32BG.P32O1GO3FP32FGL16C+.L32O1G");
Qb_PLAY ("O3D.P32BG.P32O1GO3FP32FGL16C+.L32O1GO3D.P32O1F>BP32>CO1EO3C+P32DO1DO3D+");
Qb_PLAY ("P32EO1CO3FP32F+BGP32G+AAP32BGL16A.L32BG.P32O1CO4C.P32O1GO3B.P32GA+P32B");
Qb_PLAY ("O1GO3A+P32AO1CO3G+.P32O1GO3G.P32GL16F+.L32O1GO3G.P32O1CO3A.P32O1GO3G+.");
Qb_PLAY ("P32GGP32G+O1GO3GP32F+O1CO3F.P32O1GO3E.P32GL16D+.L32O1GO3E.P32BD+.P32");
Qb_PLAY ("O1F+O3D+P32D+O1D+L16O3F+.L32O1F+>B.P32<EO3GP32AO1GO3GP32F+O1EL16O3E.");
Qb_PLAY ("L32O1GL16O3G.L32BL16B.L32O1BO3BO1BO3BO1BL16O3BP32L32O1BL16O3BP32L32O1");
Qb_PLAY ("BO3BO1A+O3BO1AO3BO1G+O3BO1GO3BO1F+O3BO1FO3BO1DP32CO4C.P32O1GO3B.P32");
Qb_PLAY ("GA+P32BO1GO3A+P32AO1CO3G+.P32O1GO3G.P32GL16F+.L32O1GO3G.P32O1CO3A.P32O1");
Qb_PLAY ("GO3G+.P32GGP32G+O1GO3GP32F+O1CO3F.P32O1GO3E.P32GL16D+.L32O1GO3E.P32BG.");
Qb_PLAY ("P32O1GO3FP32FGL16C+.L32O1GO3D.P32BG.P32O1GO3FP32FGL16C+.L32O1GO3D.");
Qb_PLAY ("P32O1F>BP32>CO1EO3C+P32DO1DO3D+P32EO1CO3FP32F+BGP32G+AAP32BGL16A.L32B");
Qb_PLAY ("G.P32O1CO4C.P32O1GO3B.P32GA+P32BO1GO3A+P32AO1CO3G+.P32O1GO3G.P32GL16F+.");
/*

Qb_PLAY ("L32O1GO3G.P32O1CO3A.P32O1GO3G+.P32GGP32G+O1GO3GP32F+O1CO3F.P32O1GO3E.");
Qb_PLAY ("P32GL16D+.L32O1GO3E.P32O1DO3D.P32O1F+O3DP32DO1DL16O3A.L32O1F+O3D.");
Qb_PLAY ("P32O1C+O3D+.P32O1GO3D+P32D+O1C+L16O3A+.L32O1GP16DO3BP32>DO1GO4C+P32");
Qb_PLAY ("CO1DO3B.P32<C>A.P32O1BL16O3G.L32O1G>G<G>G<G>G<F>F<E>E<D>D<CL16>C.L32G");
Qb_PLAY (">E<G>E<GL16>EL32O1G>GL16>E.L32O1CL16>C.L64<B>BL32>EO1C>C<C+>C+<D>DL64");
Qb_PLAY ("<D+>D+L32>EO1E>E<FL16>FL32GB>F<B>F<BL16>FL64O1E>EL32BL16>F.L32O1DL16>");
Qb_PLAY ("DL32G>DFDFDL16FL32<B>DL16F.L32O1AL16>A.L32>DFDFDL16FL32O1G>GL16>F.L32O1");
Qb_PLAY ("F>F<G>GL64<F>FL32>FO1E>E<D>D<E>EL64<F>FL32>FO1D>D<CL16>C.L32G>E<G>E<G");
Qb_PLAY ("L16>EL32<EGL16>E.L32GL16O1G.L32O3CECECL16EL32<G>CL16E.L32O1CL16>C.L32");
Qb_PLAY ("G>E<G>E<GL16EL32G<GL16O3E.L32O1CL16>C.L64B<BL32O3EO1C>C<D>D<E>EL64<F");
Qb_PLAY (">FL32>EO1G>G<F+L16>F+.L32>CF+CF+CL16F+L32<A>CL16F+.L32O1CL16>CL32A>D+F+");
Qb_PLAY ("<A>F+O1BL16O3F+L32<ACL16>F+.L32O1EL16>E.L32>CGCGO1CL16>C.L32>EGEGO1DL16");
Qb_PLAY (">D.L32>DGDGGL16O1G.L32O3FGFGO1CL16O3C.L32B<B<A>A<G>G<F>F<E>E<D>D<CL8>C.");
Qb_PLAY ("P32L32GL8<G.P32L32CL16>C.L32G>E<G>E<GL16>EL32O1G>GL16>E.L32O1CL16>C.");
Qb_PLAY ("L64<B>BL32>EO1C>C<C+>C+<D>DL64<D+>D+L32>EO1E>E<FL16>FL32GB>F<B>F<BL16");
Qb_PLAY (">FL64O1F>FL32BL16>F.L32O1DL16>DL32G>DFDFDL16FL32<B>DL16F.L32O1AL16>A.");
Qb_PLAY ("L32>DFDFDL16FL32O1G>GL16>F.L32O1F>F<G>GL64<F>FL32>FO1E>E<D>D<E>EL64<F>");
Qb_PLAY ("FL32>FO1D>D<CL16>C.L32G>E<G>E<GL16>EL32<EGL16>E.L32GL16O1G.L32O3CECEC");
Qb_PLAY ("L16EL32<G>CL16E.L32O1CL16>C.L32G>E<G>E<GL16EL32G<GL16O3E.L32O1CL16>C.");
Qb_PLAY ("L64B<BL32O3EO1C>C<D>D<E>EL64<F>FL32>EO1G>G<F+L16>F+.L32>CF+CF+CL16F+");
Qb_PLAY ("L32<A>CL16F+.L32O1CL16>CL32A>D+F+<A>F+O1BL16O3F+L32<ACL16>F+.L32O1E");
Qb_PLAY ("L16>E.L32>CGCGO1CL16>C.L32>EGEGO1DL16>D.L32>DGDGGL16O1G.L32O3FGFGO1CL16");
Qb_PLAY ("O3C.L32B<B<A>A<G>G<F>F<E>E<D>D<CL16>C.L32>E>C<E>C<EL8>CP8L16O1FL32A>CL8");
Qb_PLAY ("F.P16L16<E.P32DL32A>CL16F.P32L32<DP32CP32DP32EP32L16FL32A>CL4FL16<E.");
Qb_PLAY ("P32DL32A>CL16F.P32L32<DP32CP32DP32EFL16A.L32CL8F.P32L32CL16F.L32FL16A+.");
Qb_PLAY ("L32CL16F.L32FL16B.L32CL16F.L32FL16>C.L32<CL8A.P32L32CL16A.L32FL16>D.");
Qb_PLAY ("L32<CL16F.L32FL16>E.L32<CL16A.L32C+L16>F.L32<C+L8G+.P32L32C+L16G+.L32C+");
Qb_PLAY ("L16>D+.L32<C+L16G+.L32C+L16>C+.L32<C+L16G+.L32FL16>C.L32<CL8A.P32L32C");
Qb_PLAY ("L16A.L32FL16>C.L32<CL16A.L32FL16>C.L32<CL16A.L32A+L16>D.L32<FL8A+.");
Qb_PLAY ("P32L32FL16A+L32A+>DL16A+L32<FA+L16A+.L32>C+L16A+.L32<FL16A+L32C>CL16");
Qb_PLAY ("A.L32<FL8A.P32L32FL16AL32C>CL16G.L32<FL16AL32C>CL16F.L32<FL16AL32A+>D");
Qb_PLAY ("L16A.L32<FL8B.P32L32FL16BL32G>DL16G.L32<FL16BL32G>D+L16F+L32<F+GL16B.");
Qb_PLAY ("L32CL16>AL32<EGL16A+.L32CL16>GL32<EGL16A+.L32CL16>E.L32<GL16A+.L32C");
Qb_PLAY ("L16>DL32<GA+L16>C+L32FCL16A.L32<CL8F.P32L32CL16FL32FA+L16>A+.L32<CL16");
Qb_PLAY ("AL32FBL16>BL32<CFL16AL32F>CL16>C.L32O1CL8A.L32CFL16AL32F>DL16>D.L32O1");
Qb_PLAY ("CL16AL32F>EL16>EL32O1CFL16AL32C+>FL16>F.L32O1G+L8>C+.L32<FG+L16>C+L32");
Qb_PLAY ("<C+>GL16>G.L32O1FL16BL32C+>G+L16>G+L32O1FG+L16BL32C>AL16>A.L32O1FL8A.");
Qb_PLAY ("P32L32FL16AL32F>FL16>F.L32O1AL16>CL32<A>FL16>FL32O1FAL16>CL32BG+L16>");
Qb_PLAY ("G+.L32O1GL8>D.P32L32<GL16>DL32BGL16>G.L32O1F+L16>DL32BFL16>F.L32O1GL16>");
Qb_PLAY ("DL32<CO3DL16>D.L32O1AL16>CL32<CO3CL16>C.L32O1AL16>CL32<C>AL16>A.L32O1");
Qb_PLAY ("AL16>CL32<C>FL16>F.L32O1AL16>CL32<G>GL16>G.L32O1FL16BL32G>DL16>D.L32O1");
Qb_PLAY ("GL16BL32C>EL16>E.L32O1GL16>CL32<C>GL16>G.L32O1A+L16>CL32<F>FL16>F.L32O1");
Qb_PLAY ("AL8>C.L32<FAL16>CL32<FAL16>C.L32A>A<A>A<AL16>A.L32<AL16>A.L32AL16O1A.");
Qb_PLAY ("L32AABBC>C<C+>C+<D>D<D+>D+<E>E.P32<EL16>E.L32<C+L16>C+.L32AL16<A.L32");
Qb_PLAY ("FL16>F.L32<E>E<D>D<C+>C+<D>D<E>E<C+>C+AL16<A.L32B>C+L16<BL32A");
Qb_PLAY ("L8A.P32L32CL16>C.L32<C>C<C+>C+<D>D<E>E<F>F<F+>F+<G>G.");
Qb_PLAY ("P32<GL16>G.L32<EL16>E.L32<CL8>CL16A+.P32F+L32A.P64L16G.");
Qb_PLAY ("P32C.L32<A+L16>A+.L32<F+>F+<A>A<GL16>G.L32<CL16>C.L32C");
Qb_PLAY ("<CC+C+DDD+D+EEFFF+F+GGG+L16G+.L32AL16A.L32A+L16A+.L32B");
Qb_PLAY ("L16B.L32FL64O3CFL16AL32<CFCFCL16F.L32CL16F.L32FA+L16>A+");
Qb_PLAY ("L32<CL16F.L32FBL16>BL32<CL16F.L32FL64>FAL16>CL32O1A>F");
Qb_PLAY ("<A>F<AL16>F.L32<AL16>F.L32F>DL16>DL32O1AL16>F.L32F>EL16>E");
Qb_PLAY ("L32O1AL16>FL32C+<C+L64O3G+>C+L16FL32O1G+>C+<G+>C+<G+L16>C+.");
Qb_PLAY ("L32<G+L16>C+L32C+<C+O3D+L16>D+L32O1FL16>C+L32C+<C+O3C+");
Qb_PLAY ("L16>C+L32O1FL16>C+L32F<FL64O3FAL16>CL32O1A>F<A>F<AL16>F.");
Qb_PLAY ("L32<AL16>FL32F<FO3CL16>CL32O1AL16>FL32F<FO3CL16>CL32O1A");
Qb_PLAY ("L16>F.L32A+L64>FA+L16>DL32O1A+>D<A+>D<A+L16>DL32<FA+L16>D.");
Qb_PLAY ("L32A+>A+L16>A+L32O1FL16>D.L32A+>A+L16>A+L32O1FL16>C+L32C");
Qb_PLAY ("<CL64O4CFL16AL32O1F>C<F>C<FL16>CL32<FAL16>CL32C<CO3GL16>G");
Qb_PLAY ("L32O1FL16>CL32C<CO3FL16>FL32O1AL16>FL32C<CL64O4DFL16A");
Qb_PLAY ("L32O1G>F<G>F<GL16>FL32<GBL16>FL32G<GO3GL16>GL32O1BL16>F");
Qb_PLAY ("L32G<GO3F+L16>F+L32O1BL16>FL32C<CL64O4CEL16AL32O1A+L16>E");
Qb_PLAY ("L32C<CO3GL16>GL32O1A+L16>EL32C<CL64O3GA+L16>EL32O2CL16E");
Qb_PLAY ("L32C<CO3DL16>DL32O1A+O3C+L16>C+L32FL64<CFL16AL32O1A>F");
Qb_PLAY ("<A>F<AL16>FL32<A>CL16FL32F<F>A+L16>A+L32<CL16FL32F<F>B");
Qb_PLAY ("L16>BL32<CL16FL32F<FL64O3FAL16>CL32O1A>F<A>F<AL16>FL32<A");
Qb_PLAY (">CL16FL32F<FO3DL16>DL32O1AL16>FL32F<FO3EL16>EL32O1AL16>F");
Qb_PLAY ("L32C+<C+L64O3G+>C+L16FL32O1G+>C+<G+>C+<G+L16>C+L32<G+");
Qb_PLAY (">C+L16FL32C+<C+O3GL16>GL32O1BL16>FL32C+<C+O3G+L16>G+L32O1B");
Qb_PLAY ("L16>FL32C<CL64O4CFL16AL32O2CFCFCL16FL32<A>CL16F.L32A>F");
Qb_PLAY ("L16>FL32O1A>CL16FL32A>FL16>FL32O1A>CL16FL32G+L64>FBL16>F");
Qb_PLAY ("L32O1G+>F<G+>F<G+L16>FL32<G+BL16>FL32G+<G+O3EL16>EL32O1B");
Qb_PLAY ("L16>FL32B<BO3DL16>DL32O1BL16>FL32C<CL64O3FAL16>DL32O2C");
Qb_PLAY ("L16FL32C<CL64O3FAL16>CL32O2CL16FL32C<CO3AL16>FL32O1AL16>F");
Qb_PLAY ("L32C<CO3FL16AL32O1AL16>FL32C<CL64O3CAL16>CL32O2CFCFCL16F");
Qb_PLAY ("L32<A>CL16FL32C<CO3AL16>CL32O1GL16>EL32C<CO3GL16>CL32O1A+");
Qb_PLAY ("L16>EL32<F>C>FL16>FL64O2C+>EL32>E<G>GO2C>FL16>FL64O2D");
Qb_PLAY (">EL32>E<G>GL64O1F>AL32>FL16>FP8L64O1F>CA>FL32>CL16FP8");

*/


delay(10000);  
}
 
[/code]

А можно расшифровать этот поток сознания?

Товарищ выходы четырех вибрирующих таймеров завел через резисторы на усилок и ему понравилось. Теперь хочет чтобы ардуина подобным образом ноты проигрывала, но как прописать ей это - не знает.

Именно так. Практически все аккорды- это 2-4 однотонных звука. Понятно что это прямоугольник, что это не гармонический сигнал. Пока нужна помощь в переделке скетча.

Посмотрел на этот "стандарт АВС". Там для записи аккордов используют квадратные скобки. типа 

"G"[G2 B2 d2] [G B] [G B d]

Добавить их декодирование и все. 

Если б дело в записи было. Аккорд- полифоничный звук- т.е. несколько нот(одночастотных звуков) смешиваются . Причем в разных устройствах и муз. инструментах по-разному. А у нас только 1 источник, да еще с прямоугольником на выходе. Ну это следующий этап, пока нужно одновременно- четко синхронизировано задействовать 4-5 выходов. В тупую разчетверять код- мне не нравиться. Может у сообщества будут другие идеи. Тут есть увлеченные натуры (только титановый велосипед для кнопки чего стоит). А я практик. К тому скетчу прилагается еще 130 мелодий, ну и писать их нетрудно. В итоге бесконечно не повторяющийся будильник.

У сообщества всегда есть какие-то свои идеи, но кто их будет реализовывать в данном случае..

Я конечно. Но пока ничего красивого не придумывается.

Наверно нужно написать цикл.

vganin, посмотрите этот проект и выкиньте из него все, что Вам не нужно. http://arduino.ru/forum/proekty/floppy-hdd-music

Спасибо за доверие, повеселили. Я даже агломеративно в принципе этот код обозреть не смогу(я уж совсем начинающий). ну и подходы разные. Но еще посмотрю.

Видите ли, vganin, звук на микроконтроллере можно генерировать различными способами:

1. Чисто программно. По прямой аналогии в blink и blink without delay. Только частота повыше. Вот именно с "частота повыше" и будут основные сложности, т.к. при высоких частотах выдержать достаточно строгую периодичность импульсов проблематично. 

2. Чисто аппаратно через таймер. В кристалле 328 только один 16-разрядный таймер. 8-разрядных таймеров 2, но вследствие недостаточного разрешения ноты, сгенерированные ими будут довольно фальшивыми. Тем не менее, этот способ вполне хорош для реализации на Меге, которая имеет как раз 4 16-разрядных таймера.

3. Программно-аппаратный, основанный на аппаратных прерываниях. При каждом прерывании контроллер смотрит, а не пора ли переключать какой-либо канал. Здесь требуется адекватный выбор частоты прерываний с точки зрения баланса между погрешностью нот и количеством голосов.  Именно этот способ использовался в предложенном мною проекте.

На что ориентироваться - выбирать Вам.

PS. Добавлю: строго говоря, полноценный звук на контроллерах семейства AVR вообще сгенерировать невозможно, поэтому выше термин "звук" правильнее будет заменить на "прямоугольный сигнал звуковой частоты".

Не поймите превратно, я не программист в том виде, которые присутствуют на форуме. я занимался системами для зданий и сооружений. Там простые алгоритмы, отиентированые языки(даже языками не назовешь). И без Вашего замечания о том , что Нано имеет только 1 таймер на 16 бит, я бы через год допер, что функция tone() одновременно обрабатывает только 1 выход.  но мне этого и не нужно.

Если в скетче есть такая конструкция

[code]

#include "pitches.h"

int biz1=12;
int biz2=11;
int biz3=10;
int biz4=9;

int melody1[] = {
  NOTE_C7, NOTE_A7, NOTE_A7, NOTE_G7};
int melody2[] = {
  NOTE_A1, NOTE_F1, NOTE_C1, NOTE_C1};
int melody3[] = {
  NOTE_G1, NOTE_C1, NOTE_C1, NOTE_D1};
int melody4[] = {
  NOTE_D4, NOTE_AS4,NOTE_AS4,NOTE_A4}; 
  

int Durations[] = {4,4,4,4};

void setup(){}

void loop() {
   for(int i=0;i<2;i++){
   for (int Note = 0; Note < 4; Note++) {
   int Duration = 5000/Durations[Note];
   tone(biz1, melody1[Note],Duration);
   tone(biz2, melody2[Note],Duration);
   tone(biz3, melody3[Note],Duration);
   tone(biz4, melody4[Note],Duration);
   int pauseNotes = Duration * 1.30;
   delay(pauseNotes);
     noTone(biz1); }
    delay(200);}
  delay(6000);
} 
[/code]

то каждый выход ардуино дает свой ощутимый и слышимый даже мной(у меня нет слуха)вклад. пробовал на макете

Если интересно, то у автора(чей скетч я пытаюсь переосмыслить) есть архив с мелодиями. Очень сносно для неповторяющегося будильника

http://arduino.ru/forum/programmirovanie/funktsiya-qbplay-proigryvatel-interpretator-muzyki-iz-simvolnykh-strok

Треугольник(Интегрирующий ОУ) и несколько диодов дают практически чистый гармонический спектр до 10 кгц. сейчас моделирую в протеусе

Так это в общем -основная цель.

   tone(biz1, melody1[Note],Duration);
   tone(biz2, melody2[Note],Duration);
   tone(biz3, melody3[Note],Duration);
   tone(biz4, melody4[Note],Duration);
   int pauseNotes = Duration * 1.30;
   delay(pauseNotes);

A я вот, хоть убейте, не пойму - это вообще должно работать?

Ибо:

Only one tone can be generated at a time. If a tone is already playing on a different pin, the call to tone() will have no effect. If the tone is playing on the same pin, the call will set its frequency.

Пост №41 отменяется. Ничего там не смешивается. я лоханулся. функция tone() всегда обрабатывает первый по программе пин.

прошу прощения.

В любом случае нужно знать особенности "железа", чтобы придумать, как его заставить делать то, что нужно, и понять, что на имеющемся "железе" принципиально не реализуемо.