LXF160:Arduino взволнован

Подписка на печатную версию Весь 2015 год (12 номеров) Первое полугодие (6 номеров) Второе полугодие (6 номеров)

Подписка на электронную версию Весь 2015 год (12 номеров) Первое полугодие (6 номеров) Второе полугодие (6 номеров)

Подшивки старых номеров журнала (печатные версии) Весь 2014 год (12 номеров) Первое полугодие (6 номеров) Второе полугодие (6 номеров)

Элек­тро­ни­ка. Ап­па­рат­ные про­ек­ты с от­кры­тым ко­дом, рас­ши­ряющие ваш кру­го­зор.

Arduino: Го­ним вол­ну таймером

Хит­ро­ум­но ма­ни­пу­ли­руя с тай­ме­ра­ми, Ник Вейч пре­вра­ща­ет Arduino в ге­не­ра­тор ко­ле­ба­ний.

В про­шлый раз мы го­во­ри­ли о... вре­мени, а имен­но – в под­роб­но­стях рас­смот­ре­ли ра­бо­ту со счет­чи­ком Timer1 и уз­на­ли, как с по­мо­щью кое-ка­ких низ­ко­уровневых манипу­ля­ций сде­лать то, что нам нуж­но: за­пустить несколь­ко на­деж­ных про­це­дур пре­ры­вания ти­па ре­ле вре­мени. Но, как это ни бы­ло пре­крас­но, воз­мож­но­сти тай­ме­ра го­раз­до ши­ре, и се­го­дня мы рас­смот­рим еще несколь­ко при­ме­ров его ис­поль­зо­вания. Мо­же­те не тре­во­жить свой ящик с де­та­ля­ми, хо­тя ди­на­мик, по­жалуй, не повре­дит.

Впро­чем, пе­ред тем как пе­рей­ти к са­мим тай­ме­рам, вы­ясним, как они ис­поль­зу­ют­ся в са­мом Arduino. Вы когда-нибудь ин­те­ре­со­ва­лись тем, как чис­то циф­ро­вое уст­рой­ст­во фор­ми­ру­ет ана­ло­го­вый вы­ход? Этот спе­ци­аль­ный ре­жим вы­ход­но­го сиг­на­ла мож­но вклю­чить на вы­во­дах 3, 5, 6, 9, 10 и 11 Arduino на ба­зе Atmega168 и Atmega368. При за­пи­си, на­при­мер, зна­чения 128 в один из этих вы­во­дов зна­чение вы­ход­но­го сиг­на­ла ока­зы­ва­ет­ся рав­ным (в дан­ном слу­чае) око­ло 2,5 В.

Про­ис­хо­дит сле­дую­щее: на ко­рот­кий ин­тер­вал вре­мени вы­вод вклю­ча­ет­ся и за­тем сно­ва вы­клю­ча­ет­ся. Он генери­ру­ет пря­мо­уголь­ное ко­ле­бание, ко­то­рое в среднем об­ра­зу­ет сиг­нал на­пря­жением 2,5 В. В ре­аль­но­сти это лишь очень бы­строе пе­ре­клю­чение ме­ж­ду 5 В и 0 В. Зна­чение, ко­то­рое вы за­пи­сы­вае­те, оп­ре­де­ля­ет со­от­но­шение вре­мени в со­стоянии ВКЛ ко вре­мени в со­стоянии ВЫКЛ (ко­эф­фи­ци­ент за­полнения, час­то вы­ра­жае­мый в про­цен­тах). Как и при лов­ко­сти рук, ско­рость здесь – важ­ный фак­тор. Хо­тя среднее на­пря­жение, неза­ви­си­мо от то­го, вклю­чать и вы­клю­чать его два­ж­ды или две­сти раз в се­кун­ду (при том же со­от­но­шении про­дол­жи­тель­но­сти ВКЛ/ВЫКЛ), бу­дет оди­на­ко­во, в пер­вом слу­чае вы по­лу­чи­те ми­гаю­щий свет, а во вто­ром свет ока­жет­ся туск­лым (на са­мом де­ле он про­сто ми­га­ет очень бы­ст­ро). Обыч­но час­то­та пря­мо­уголь­ных ко­ле­баний со­став­ля­ет око­ло 500 Гц при вы­зо­ве функ­ции digitalWrite(), но мож­но из­менить са­ми ча­сы, что­бы по­лу­чить дру­гие зна­чения.

Мо­жет иметь зна­чение основ­ная час­то­та ши­рот­но-им­пульс­ной мо­ду­ля­ции (ШИМ). На­стоя­щие элек­трон­ные ком­понен­ты су­ще­ст­ву­ют в ре­аль­ном ми­ре, и хо­тя вре­мя на­рас­тания сиг­на­ла (тре­буе­мое для из­менения вы­ход­но­го сиг­на­ла с ну­ля [LOW] до единицы [HIGH]) в Arduino из­ме­ря­ет­ся в на­но­се­кун­дах, вре­мя, необ­хо­ди­мое для вклю­чения или вы­клю­чения элек­тро­магнита, лег­ко мо­жет быть в 1000 раз боль­ше. По­это­му иногда основ­ную час­то­ту ШИМ нуж­но из­менить. Для вы­во­дов 11 и 3, ис­поль­зую­щих встро­ен­ный Timer2, это не по­влия­ет на осталь­ную часть ва­шей про­грам­мы. А вот для вы­во­дов 5 и 6 из­менение час­то­ты (т. е. из­менение зна­чения пред­ва­ри­тель­но­го де­ли­те­ля час­то­ты) име­ет по­боч­ный эф­фект. С по­мо­щью им­пуль­сов это­го тай­ме­ра ра­бо­та­ют функ­ции Arduino millis() и delay(), по­это­му умень­шение час­то­ты мо­жет уве­ли­чить за­держ­ки.

Ос­но­вы ШИМ

Тай­мер управ­ля­ет ре­жи­мом ШИМ вполне оче­вид­ным об­ра­зом. Тай­мер под­счи­ты­ва­ет пе­рио­ды сиг­на­ла ВКЛ до сво­его пре­де­ла в 255 (для Timer2) и за­тем пе­ре­пол­ня­ет­ся, сно­ва на­чи­ная от­счет с ну­ля. Мож­но на­стро­ить ре­гистр сравнения на лю­бое из зна­чений от 0 до 255, и когда счет­чик достигнет вы­бран­но­го зна­чения, в за­ви­си­мо­сти от за­дан­но­го ре­жи­ма мо­гут быть вы­полнены раз­лич­ные дей­ст­вия, обыч­но вклю­чаю­щие ав­то­ма­ти­че­скую уста­нов­ку зна­чения оп­ре­де­лен­но­го вы­во­да.

Как всегда на мик­ро­схе­мах Atmega, есть несколь­ко раз­лич­ных ва­ри­ан­тов воз­мож­ных дей­ст­вий. В са­мом про­стом слу­чае ре­гистр сравнения пе­ре­клю­ча­ет вы­ход в «единицу» и сбра­сы­ва­ет­ся сно­ва при пе­ре­за­пуске счет­чи­ка. Тогда вы­со­кое зна­чение ре­ги­ст­ра сравнения оз­на­ча­ет боль­ше вре­мени «вы­клю­че­но» и мень­ше «вклю­че­но». Так­же мож­но ис­поль­зо­вать один из ре­ги­ст­ров сравнения в ка­че­­ст­ве верхнего пре­де­ла счет­чи­ка, та­ким об­ра­зом бо­лее точ­но от­ре­гу­ли­ро­вав его час­то­ту (а так­же вы­чис­ления ко­эф­фи­ци­ен­та за­полнения).

Мы бу­дем поль­зо­вать­ся ШИМ с кор­рек­ци­ей фа­зы, по­ла­гая, что сиг­нал дости­га­ет выс­шей точ­ки ров­но по­сре­ди вре­мен­но­го ин­тер­ва­ла. Это оз­на­ча­ет и то, что сгенери­ро­ван­ный сиг­нал име­ет са­мый низ­кий уро­вень в на­ча­ле и в кон­це это­го вре­мен­но­го ин­тер­ва­ла. Для генера­ции сиг­на­лов пра­виль­ной фор­мы, на­при­мер, для управ­ления дви­га­те­лем или да­же воспро­из­ве­дения зву­ка, это жизнен­но важ­но.

В ре­жи­ме кор­рек­ции фа­зы счет­чик ШИМ ве­дет се­бя ина­че – сна­ча­ла он досчи­ты­ва­ет до 255, а по­том вме­сто сбро­са на­чи­на­ет счи­тать об­рат­но до ну­ля. Ес­ли ре­гистр сравнения на­стро­ен на из­менение вы­ход­но­го сиг­на­ла в обо­их на­прав­лениях, то в ка­ж­дом на­прав­лении на со­стояния ВКЛ и ВЫКЛ при­хо­дят­ся оди­на­ко­вые ин­тер­ва­лы вре­мени, и ко­эф­фи­ци­ент за­полнения со­хра­ня­ет­ся. Яв­ный недоста­ток это­го ре­жи­ма в том, что эф­фек­тив­ная час­то­та умень­ша­ет­ся вдвое. Впро­чем, это не долж­но стать про­бле­мой для нас, так как при час­то­те про­цес­со­ра 16 МГц по­ло­са оста­ет­ся при­ем­ле­мой для ау­дио- и дру­гих цен­ных сиг­на­лов.

Боль­ше шу­ма

Мы мо­жем восполь­зо­вать­ся воз­мож­но­стя­ми ШИМ Timer2 для генера­ции зву­ка. В пре­ды­ду­щих экс­пе­ри­мен­тах со зву­ком мы по­ла­га­лись толь­ко на из­ры­гаю­щую би­ты встро­ен­ную функ­цию tone(), ко­то­рая фор­ми­ру­ет при­ем­ле­мые, раз­ве что зву­ча­щие сер­ди­то, пря­мо­уголь­ные ко­ле­бания на за­дан­ном вы­во­де. Но с воз­мож­но­стя­ми ШИМ и неболь­шим хит­рым ко­дом мы мо­жем соз­да­вать звук лю­бой фор­мы и раз­ме­ра. Конеч­но, хо­тя мы счи­та­ем этот сиг­нал зву­ко­вым, фак­ти­че­­ски мы соз­да­ем сиг­на­лы, при­год­ные в са­мых раз­ных си­туа­ци­ях – как для тес­ти­ро­вания дру­го­го обо­ру­до­вания, так и для непо­сред­ст­вен­но­го управ­ления дви­га­те­ля­ми.

Для генера­ции ко­ле­баний мы мо­жем ими­ти­ро­вать ана­ло­го­вые зна­чения, ис­поль­зуя ШИМ на вы­со­кой час­то­те для вклю­чения и вы­клю­чения вы­во­да. Но нуж­но за­дать это зна­чение на­деж­но. Тут нам по­мо­жет тот же са­мый тай­мер. Как и у Timer1, ко­то­рым мы поль­зо­ва­лись в пре­ды­ду­щей ста­тье, у Timer2 есть век­тор пре­ры­ваний. В ре­жи­ме ШИМ с кор­рек­ци­ей фа­зы его мож­но за­ста­вить сра­ба­ты­вать по за­вер­шению пол­но­го цик­ла счет­чи­ка (т. е. когда счет­чик досчи­тал до 255 и вер­нул­ся об­рат­но к 0). Свя­зав с этим про­це­ду­ру об­ра­бот­ки пре­ры­вания, при необ­хо­ди­мо­сти мож­но ме­нять зна­чение вы­во­да ШИМ на ка­ж­дом цик­ле вы­во­да.

Пол­ный цикл тай­ме­ра со­став­ля­ет 510 так­тов (конеч­ные зна­чения счи­та­ют­ся толь­ко один раз), и это да­ет нам 16 МГц/510 = 31,372 кГц – бо­лее чем доста­точ­но для соз­дания ау­дио­сиг­на­ла. Как и в про­шлый раз, для за­дания кор­рект­ных зна­чений тай­ме­ра необ­хо­ди­мо немно­го по­ра­бо­тать со спе­ци­аль­ны­ми ре­ги­ст­ра­ми мик­ро­схе­мы Atmega. Вот код для уста­нов­ки тай­ме­ра:

TCCR2A = _BV(COM2B1) | _BV(WGM20);

TCCR2B = _BV(CS20);

TIMSK2 = _BV(TOIE2);

pinMode(3,OUTPUT);

Ес­ли вы не чи­та­ли про­шлой ста­тьи, то вряд ли что-то по­ня­ли. Мы не бу­дем воз­вра­щать­ся к по­би­то­вой ариф­ме­ти­ке (то, что де­ла­ет сим­вол |), но немно­го по­яснить про­ис­хо­дя­щее все же сто­ит. TCCR2A и TCCR2B – два 8-би­то­вых ре­ги­ст­ра (т. е. две спе­ци­аль­ные об­лас­ти па­мя­ти), ко­то­рые со­дер­жат зна­чения, управ­ляю­щие ра­бо­той тай­ме­ра. Сре­ди про­че­го они оп­ре­де­ля­ют, ка­кой ре­жим ШИМ ис­поль­зу­ет­ся и как бы­ст­ро он ра­бо­та­ет. Ка­ж­дый бит или на­бор би­тов за­да­ет оп­ре­де­лен­ный ас­пект ра­бо­ты тай­ме­ра. Ус­та­нов­лен­ный бит COM2B1 го­во­рит ком­па­ра­то­ру B, что в ре­жи­ме ШИМ с кор­рек­ци­ей фа­зы нуж­но сбро­сить вы­ход в ноль при дости­жении верхнего пре­де­ла и уста­но­вить его в зна­чение верхнего пре­де­ла при дости­жении ну­ля (об­рат­ный ре­жим). Бит WGM20 пе­ре­во­дит тай­мер в ре­жим ШИМ с кор­рек­ци­ей фа­зы. Три менее важ­ных би­та в TCCR2B уста­нав­ли­ва­ют зна­чение де­ли­те­ля час­то­ты тай­ме­ра (сколь­ко ти­ков сис­тем­ных ча­сов нуж­но ждать для об­нов­ления зна­чения тай­ме­ра). Ес­ли уста­но­вить толь­ко бит CS20, тай­мер бу­дет ра­бо­тать с той же час­то­той, что и сис­тем­ные ча­сы (а сброс всех би­тов в ноль от­клю­ча­ет тай­мер). TIMSK2 – дру­гой ре­гистр, ко­то­рый на сей раз со­дер­жит мас­ку пре­ры­ваний. При возник­но­вении оп­ре­де­лен­но­го со­бы­тия (на­при­мер, дости­жения тай­ме­ром кон­ца цик­ла) про­цес­сор счи­ты­ва­ет зна­чение это­го ре­ги­ст­ра, что­бы по­смот­реть, на­зна­че­но ли пре­ры­вание для это­го со­бы­тия. Ес­ли да, он об­ра­ща­ет­ся к век­то­ру пре­ры­ваний, дру­гой спе­ци­аль­ной об­лас­ти па­мя­ти, в ко­то­рой хранит­ся ад­рес про­це­ду­ры, ко­то­рую нуж­но за­пустить.

На­конец, мы на­зна­ча­ем вы­ход­ной сиг­нал на циф­ро­вой вы­вод 3. По­че­му на него? А он на­пря­мую управ­ля­ет­ся ре­ги­ст­ром сравнения B тай­ме­ра Timer2. Же­лая восполь­зо­вать­ся вы­во­дом 11, мож­но взять вме­сто него ре­гистр сравнения A тай­ме­ра Timer2. Толь­ко два этих вы­во­да управ­ля­ют­ся на­пря­мую с тай­ме­ра.

Пре­ры­вание

Что­бы кор­рект­но за­дать пре­ры­вание, восполь­зу­ем­ся спе­ци­аль­ным мак­ро­сом ISR(). Де­ло в том, что ад­рес пре­ры­вания нуж­но за­гру­жать в век­тор пре­ры­вания, но по­ка мы не ском­пи­ли­ро­ва­ли про­грам­му, этот ад­рес неиз­вес­тен. Этот вол­шеб­ный мак­рос по­за­бо­тит­ся обо всем; нуж­но лишь объ­я­вить сле­дую­щую про­це­ду­ру:

ISR(TIMER2_OVF_vect){

}

Ука­зан­ный бит го­во­рит мак­ро­су, с ка­ким век­то­ром мы хо­тим свя­зать эту про­це­ду­ру. Те­перь нуж­но толь­ко за­полнить ее. Раз уж мы воз­же­ла­ли иметь несколь­ко раз­лич­ных ти­пов ко­ле­баний, есть смысл восполь­зо­вать­ся кон­ст­рук­ци­ей switch ... case. В язы­ке C она по­зво­ля­ет вы­пол­нять раз­лич­ные бло­ки ко­да в за­ви­си­мо­сти от зна­чения од­ной пе­ре­мен­ной. Она ра­бо­та­ет так:

switch(variable) {

case 1:

// что-ни­будь де­ла­ем

break;

case 2:

// что-ни­будь де­ла­ем

break;

…

default:

// ос­таль­ное не по­до­шло, сде­ла­ем это

}

Ес­ли зна­чение пе­ре­мен­ной рав­но 1, вы­пол­ня­ет­ся пер­вый блок ко­да, и т. д. Ес­ли это зна­чение не со­от­вет­ст­ву­ет ни од­но­му из бло­ков, вы­пол­ня­ет­ся блок default, но он не обя­за­те­лен. Ка­ж­дый блок сле­ду­ет за­вер­шать опе­ра­то­ром break;, по ко­то­ро­му про­ис­хо­дит вы­ход из всей струк­ту­ры, в про­тив­ном слу­чае пе­ре­мен­ная про­дол­жит сравнивать­ся с ка­ж­дым бло­ком (и в ито­ге вы­полнит­ся код по умол­чанию). По­это­му все, что нам нуж­но – пе­ре­мен­ная, ко­то­рая ска­жет нам, ка­кой сиг­нал мы генери­ру­ем. Пе­ре­мен­ная долж­на быть гло­баль­ной и за­да­вать­ся вне этой кон­ст­рук­ции, что­бы мож­но бы­ло уста­но­вить ее в основ­ном ко­де. На­зо­вем ее wave.waveform.

Да, и нуж­но сде­лать кое-что еще. Хо­тя код вы­зо­вет­ся точ­но в нуж­ный мо­мент вре­мени по пре­ры­ванию, на его вы­полнение мо­жет по­тре­бо­вать­ся раз­ное вре­мя, в за­ви­си­мо­сти от то­го, ка­кой блок ко­да бу­дет вы­полнен. Что­бы из­бе­жать дро­жаний вы­ход­но­го сиг­на­ла, мы долж­ны по­дать зна­чение ре­ги­ст­ра сравнения (т. е. на­шу ве­ли­чи­ну от 0 до 255) на вы­ход с са­мо­го на­ча­ла. За­тем мы мо­жем восполь­зо­вать­ся остав­шей­ся ча­стью пре­ры­вания для генера­ции вы­ход­но­го зна­чения для сле­дую­ще­го раза. У ком­па­ра­то­ра есть спе­ци­аль­ный ад­рес, но, к сча­стью, есть и услов­ное зна­чение, в ко­то­рое его мож­но уста­но­вить. Вы­ход­ное зна­чение бу­дет еще од­ной из этих нуд­ных гло­баль­ных пе­ре­мен­ных, по­это­му на­зо­вем его wave.output. На­ча­ло на­шей функ­ции те­перь вы­гля­дит так:

ISR(TIMER2_OVF_vect){

OCR2B = wave.output;

switch(wave.waveform) {

case 1: // пря­мо­уголь­ная вол­на

Да, мы на­чи­на­ем с пря­мо­уголь­ных ко­ле­баний! Ну, да, да, мы мог­ли сде­лать это и рань­ше, но не на тех час­то­тах, ко­то­рые те­перь у нас в рас­по­ря­жении! Пря­мо­уголь­ные ко­ле­бания до­воль­но про­сты: по­лпе­рио­да вол­на про­во­дит ввер­ху, дру­гие по­лпе­рио­да – внизу. Что­бы оп­ре­де­лить, когда ее вклю­чать и вы­клю­чать, нуж­но знать час­то­ту воспро­из­водимой но­ты(wave.frequency) и ко­ли­че­­ст­во ма­лень­ких пор­ций вре­мени, ко­то­рые уже про­шли (м-мм, wave.f_counter?). По­сле это­го генера­ция вол­ны сво­дит­ся к про­вер­ке, в ка­кой вре­мен­ной до­ле мы на­хо­дим­ся, оп­ре­де­лении, не во вто­рой ли мы по­ло­вине пол­но­го цик­ла, и вклю­чении или вы­клю­чении сиг­на­ла. Как мы зна­ем, ка­ж­дая вре­мен­ная до­ля со­став­ля­ет 1/31372,5 се­кун­ды, и де­ло лишь за неболь­шой ариф­ме­ти­кой:

case 1: // пря­мо­уголь­ная вол­на

wave.f_counter++;

if (wave.f_counter<(15686/wave.frequency)){

// пер­вая по­ло­ви­на цик­ла – вы­ход мак­си­ма­лен

wave.output=wave.volume;

}

else{

// вто­рая по­ло­ви­на цик­ла – вы­ход = 0

wave.output=0;

}

if (wave.f_counter>(31372.5/wave.frequency)){

// цикл за­вер­шен, сбо­рос счет­чи­ка

wave.f_counter=0;

}

break;

Да, мы вбро­си­ли ту­да и wave.volume – по­че­му бы нет? Тогда мы смо­жем управ­лять еще и ам­пли­ту­дой пря­мо­уголь­ных коле­баний. Мо­жет быть, сей­час вас бес­по­ко­ит, от­ку­да бу­дут брать­ся эти зна­чения и как мы бу­дем ими поль­зо­вать­ся. Не вол­нуй­тесь, имен­но так и сто­ит пи­сать код. Те­перь у нас есть все необ­хо­ди­мые па­ра­мет­ры, и мож­но соз­дать спе­ци­аль­ную пе­ре­мен­ную, где все они бу­дут хранить­ся. В пре­ды­ду­щих ру­ко­во­д­ствах мы рас­смат­ри­ва­ли струк­ту­ры, и они до­воль­но про­сты. Это лишь спо­соб за­дать со­став­ной тип дан­ных – нечто вро­де клас­са, но без ме­то­дов.

struct generator{

bool active;

uint8_t waveform;

uint16_t frequency;

uint16_t f_counter;

uint16_t duration;

uint16_t table_value;

double table_inc;

uint8_t output;

uint8_t volume;

} wave;

Мож­но по­рез­вить­ся с неко­то­ры­ми пе­ре­мен­ны­ми и ти­па­ми, но в це­лом это очень по­хо­же на го­то­вое управ­ление зву­ком (к таб­лич­ным дан­ным пе­рей­дем че­рез ми­ну­ту). Как ви­ди­те, в конец объ­яв­ления струк­ту­ры мы по­мес­ти­ли имя wave. Это зна­чит, что бу­дет соз­дан один эк­зем­п­ляр струк­ту­ры с именем wave, и для досту­па к ее эле­мен­там мы мо­жем ис­поль­зо­вать кон­ст­рук­ции wave.waveform, wave.frequency... весь­ма удоб­но, по­то­му что мы уже на­пи­са­ли код, ко­то­рый де­ла­ет имен­но это.

Мож­но ра­бо­тать с час­тя­ми этой пе­ре­мен­ной по от­дель­но­сти, но луч­ше соз­дать вспо­мо­га­тель­ную функ­цию для за­дания вы­ход­но­го зна­чения. Она мо­жет принимать один ар­гу­мент (час­то­ту) и уста­нав­ли­вать все необ­хо­ди­мые зна­чения сле­дую­щим об­ра­зом:

void playSquare (uint16_t f){

wave.waveform=1;

wave.frequency=f;

wave.f_counter=0;

wave.active=true;

wave.volume=255;

};

Здесь мы при­сваи­ва­ем бу­лев­ское зна­чение пе­ре­мен­ной wave.active. Ее мож­но ис­поль­зо­вать в ка­че­­ст­ве клю­ча в на­ча­ле про­це­ду­ры пре­ры­вания – ес­ли вол­на вы­клю­че­на, то ника­ких дей­ст­вий пред­принимать не нуж­но. Это по­мо­жет сбе­речь несколь­ко так­тов про­цес­со­ра для дру­гих дей­ст­вий.

Си­ну­сит вре­мен

Конеч­но, есть и бо­лее на­ту­раль­ные вол­ны – хо­тя бы тре­уголь­ные и си­ну­сои­даль­ные вол­ны. Си­ну­сои­даль­ная вол­на луч­ше все­го генери­ру­ет­ся с по­мо­щью таб­ли­цы зна­чений (см. врез­ку). Ма­те­ма­ти­че­­ские рас­че­ты для вы­чис­ления зна­чений на ле­ту слиш­ком за­трат­ны по вре­мени. Помните, на­ши вре­мен­ные до­ли рав­ны 1/31372,5 се­кун­ды – а на вы­полнение про­це­ду­ры от­во­дит­ся не бо­лее дан­но­го ин­тер­ва­ла, и нуж­но эко­но­мить! Оп­ре­де­лить по­ло­жение в таб­ли­це, най­ти зна­чение и ин­кре­мен­ти­ро­вать несколь­ко счет­чи­ков – это все­го несколь­ко так­тов про­цес­со­ра (из воз­мож­ных 510, ко­то­рые у нас есть), так что это про­стой под­ход.

Как оп­ре­де­лить на­ше по­ло­жение в таб­ли­це? Нам из­вес­тен раз­мер таб­ли­цы и час­то­та воспро­из­во­ди­мой но­ты – доста­точ­но вы­полнить ум­но­жение, де­ление и по­смот­реть на оста­ток. Нам не нуж­но счи­тать вре­мен­ные до­ли – все слож­ные вы­чис­ления мож­но вы­полнить за­ранее при за­дании па­ра­мет­ров вол­ны; у нас долж­ны быть толь­ко счет­чик ин­дек­са и пе­ре­мен­ная, со­дер­жа­щая ко­ли­че­­ст­во би­тов ин­дек­са, ко­то­рые нуж­но про­пускать с ка­ж­дой до­лей. Мы де­лим зна­чение счет­чи­ка на 256 и ис­поль­зу­ем оста­ток для по­лу­чения сле­дую­ще­го зна­чения. Ес­ли необ­хо­ди­ма боль­шая точ­ность, мож­но сде­лать эти зна­чения дей­ст­ви­тель­ны­ми (с пла­ваю­щей точ­кой) и ра­бо­тать с до­ля­ми зна­чений ин­дек­са (по­лу­чить два и ин­тер­по­ли­ро­вать), но раз­мер таб­ли­цы в лю­бом слу­чае дол­жен быть неве­лик – для хранения боль­шей таб­ли­цы эле­мен­тар­но не хва­тит па­мя­ти. По­это­му те­перь слож­ные рас­че­ты вы­пол­ня­ют­ся во вспо­мо­га­тель­ной функ­ции:

void playSine (uint16_t f){

wave.waveform=3;

wave.frequency=f;

wave.f_counter=0;

wave.table_value=0;

wave.table_inc=(255.0/(31372.54/wave.frequency));

wave.active=true;

}

Но реа­ли­зо­вать ее в пре­ры­ва­нии про­сто:

case 3: // си­ну­сои­даль­ная вол­на

wave.output=sinLUT[wave.table_value%256];

wave.table_value += wave.table_inc;

break;

Ни­че­го не за­бы­ли? Ах да, са­ма таб­ли­ца. Ну, это про­сто стоп­ка чи­сел – ее мож­но най­ти на DVD. Тре­уголь­ная вол­на так­же реа­ли­зо­ва­на в таб­ли­це со­от­вет­ст­вия – лениво, да? Но хо­тя зна­чения для тре­уголь­ной вол­ны доста­точ­но про­сто рас­счи­тать, ра­бо­тать с таб­ли­цей все рав­но бы­ст­рее! Ес­ли вы хо­ти­те по­слу­шать неко­то­рые зву­ко­вые час­то­ты, под­клю­чи­те ди­на­мик ме­ж­ду вы­во­дом 3 и зем­лей, же­ла­тель­но с кон­ден­са­то­ром. |