Журнал LinuxFormat - перейти на главную

LXF156:Arduino

Материал из Linuxformat
Версия от 14:57, 13 июля 2018; Olkol (обсуждение | вклад)

(разн.) ← Предыдущая | Текущая версия (разн.) | Следующая → (разн.)
Перейти к: навигация, поиск
Подписка на печатную версию
Весь 2015 год (12 номеров)
Первое полугодие (6 номеров)
Второе полугодие (6 номеров)
Подписка на электронную версию
Весь 2015 год (12 номеров)
Первое полугодие (6 номеров)
Второе полугодие (6 номеров)
Подшивки старых номеров журнала (печатные версии)
Весь 2014 год (12 номеров)
Первое полугодие (6 номеров)
Второе полугодие (6 номеров)


Элек­тро­ни­ка Хо­ти­те встро­ен­ные ча­сы? При­спо­собь­те свой Arduino

=Arduino: Са­ми со­бе­рем пла­ту=

Ус­та­ли не­ча­ян­но па­лить пла­ты Arduino? Ник Вейч ре­ша­ет со­брать свою соб­ст­вен­ную и об­на­ру­жи­ва­ет, что это про­ще, чем он ду­мал.

243518.png

На этом уро­ке мы уй­дем немно­го в сто­ро­ну от обыч­ных ста­тей, в ко­то­рых мы со­би­ра­ли схе­мы из ком­понен­тов, и со­бе­рем соб­ст­вен­ную пла­ту Arduino. Эта идея при­шла мне в го­ло­ву, когда я вы­вел из строя за­груз­чи­ки на несколь­ких схе­мах и по­на­до­би­лось пе­ре­про­грам­ми­ро­вать их, пре­вра­тив Arduino в про­грам­ма­тор.

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

Содержание

За­чем со­би­рать са­мим?

Ти­пич­ный от­вет – по­то­му что это де­шев­ле. Это спра­вед­ли­во, ес­ли у вас мно­го за­пас­ных ком­понен­тов и сво­бод­но­го вре­мени; но, прав­ду го­во­ря, го­то­вые пла­ты Arduino не так до­ро­ги. Итак, за­чем?

Помните: сво­бо­да сво­бод­но­го ПО не в том, что оно бес­плат­но, а в том, что его мож­но из­менить. Есть мас­са при­чин, по ко­то­рым вы мо­же­те за­хо­теть со­брать соб­ст­вен­ную пла­ту Arduino – мо­жет, вам нуж­ны встро­ен­ные ча­сы, или до­полнитель­ная па­мять EEPROM, или ка­кая-то дру­гая схе­ма с несколь­ки­ми тран­зи­сто­ра­ми или ре­ле на пла­те.

По су­ти, все, что мож­но сде­лать с платами-расширениями Arduino [Arduino shields], мож­но сде­лать и на самом Arduino. Ес­ли немно­го по­хит­рить, мож­но сде­лать схе­му Arduino-со­вмес­ти­мой до сте­пени со­вмес­ти­мо­сти с дру­ги­ми расширениями.

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

Ес­ли вам нуж­на толь­ко за­пас­ная Arduino, вас вполне осчастли­вит сборка ком­понен­тов на ма­ке­те – так с ними оп­ре­де­лен­но про­ще экс­пе­ри­мен­ти­ро­вать.

(thumbnail)
Ис­точ­ни­ка пи­та­ния на ос­но­ве L7805 впол­не дос­та­точ­но для ва­шей схе­мы, и он не зай­мет слиш­ком мно­го мес­та.

Пер­вое, о чем нуж­но по­ду­мать – ис­точник пи­тания. Ес­ли от него не бу­дет за­пи­ты­вать­ся слиш­ком мно­го уст­ройств, мож­но из­бе­жать USB (в за­ви­си­мо­сти от то­го, что бу­дет под­клю­чать­ся, доступ­ный ток мо­жет со­став­лять все­го несколь­ко со­тен мА – это­го не хва­тит для уди­ви­тель­ной сис­те­мы ав­то­ма­ти­че­­ско­­го осве­щения, ко­то­рую вы планируе­те); кро­ме то­го, мож­но не бес­по­ко­ить­ся о под­клю­чениях по USB.

Схе­му, безуслов­но, мож­но за­пи­тать на­пря­мую от ба­та­ре­ек. Мик­ро­схе­мы ATmega168/328 име­ют до­пуск по вход­но­му на­пря­жению от 2,7 до 6 В. По­сле­до­ва­тель­но со­единив че­ты­ре эле­мен­та AA, вы по­лу­чи­те на­пря­жение от 4,8 до 6 В (за­ря­жае­мые ак­ку­му­ля­то­ры обыч­но име­ют на­пря­жение 1,2 В, а не 1,5 В), ко­то­рое пре­красно под­хо­дит для боль­шин­ст­ва си­туа­ций, но кое-че­го сле­дует опа­сать­ся:

  • При­ло­жения, за­ви­ся­щие от ана­ло­го­вых вхо­дов, мо­гут ра­бо­тать неста­биль­но. Ес­ли вы сравнивае­те на­пря­жение с сиг­на­лом 5 В, это пре­крас­но, по­ка оно действительно рав­но 5 В. Но ба­та­рей­ки раз­ря­жа­ют­ся, и мож­но по­лу­чить зна­чи­тель­но мень­шее на­пря­жение.
  • Не­доста­точ­ное пи­тание мик­ро­схе­мы спо­соб­но при­вес­ти к неожи­дан­ным по­след­ст­ви­ям. Она мо­жет все еще ра­бо­тать с на­пря­жением 3 В, но не с той же са­мой ско­ро­стью, что мо­жет вы­зы­вать раз­но­об­раз­ные про­бле­мы.
  • Не­ста­биль­ное на­пря­жение пи­тания ве­дет к неста­биль­но­му по­ве­дению – в иде­аль­ном слу­чае оно ли­бо есть, ли­бо его нет. На­пря­жение ба­та­ре­ек бу­дет по­сте­пен­но снижать­ся по ме­ре их раз­ряд­ки, и вы мо­же­те не уз­нать о том, что уст­рой­ст­во ра­бо­та­ет непра­вильно, по­ка не про­изой­дет что-то ужас­ное.
  • Хо­тя мик­ро­схе­мы ATmega/Arduino способны нор­маль­но ра­бо­тать с та­ки­ми на­пря­жения­ми, мо­гут от­ка­зать дру­гие ком­понен­ты. Мно­гие уст­рой­ст­ва, осо­бен­но ин­те­граль­ные схе­мы, ожи­да­ют ста­биль­но­го из­вест­но­го на­пря­жения.

По этим и дру­гим при­чи­нам сто­ит вклю­чить в пла­ту неко­то­рую схе­му ре­гу­ли­ров­ки на­пря­жения. Конеч­но, мож­но ку­пить ре­гу­ли­руе­мый ис­точник пи­тания 5 В, но от­дель­ная схе­ма ре­гу­ли­ров­ки на­пря­жения по­зво­лит вам ис­поль­зо­вать бо­лее де­ше­вые нере­гу­ли­руе­мые ис­точники пи­тания или дру­гие ис­точники.

К сча­стью, сде­лать это до­воль­но про­сто. Се­рия ин­те­граль­ных схем 78xx су­ще­ст­ву­ет уже дав­но и до­ка­за­ла свою на­деж­ность и по­пу­ляр­ность, что от­ра­зи­лось и в доступ­ной цене. У этих мик­ро­схем, как и поч­ти у всех по­доб­ных ре­гу­ля­то­ров на­пря­жения, три вы­во­да – вход, зем­ля и вы­ход.

Для сгла­жи­вания и бу­фе­ри­за­ции вход­но­го сиг­на­ла им так­же по­тре­бу­ют­ся внешние кон­ден­са­то­ры – их па­ра­мет­ры бу­дут при­ве­де­ны в ин­ст­рук­ции про­из­во­ди­те­ля, но не сто­ит при­вя­зы­вать­ся к зна­чениям: для на­ших це­лей для ра­бо­ты с L7805 пре­крас­но по­дой­дут кон­ден­са­то­ры ем­ко­стью 100 мкФ, и сго­дят­ся лю­бые кон­ден­са­то­ры от 22 до 470 мкФ.

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

Ре­гу­ля­тор снизит вход­ное на­пря­жение на па­ру вольт, по­это­му луч­ше все­го восполь­зо­вать­ся бло­ком пи­тания от бытовой сети на 7,5 В, хо­тя пре­крас­но по­дой­дут и дру­гие с на­пря­жением до 12 В. Впро­чем, лишние воль­ты пере­ходят в те­п­ло, по­это­му уч­ти­те – пре­об­ра­зование 12 В в 5 В мо­жет по­тре­бо­вать те­п­ло­от­во­да.

Мик­ро­схе­мы и ком­понен­ты

(thumbnail)
Ма­кет с мик­ро­кон­трол­ле­ром ATmega и до­пол­ни­тель­ны­ми ком­по­нен­та­ми, не­об­хо­ди­мы­ми для пре­вра­ще­ния его в Arduino.

Ра­зо­брав­шись с ис­точником пи­тания, по­ду­ма­ем о мик­ро­схе­ме ATmega. Конеч­но, ее мож­но раз­мес­тить пря­мо на ма­ке­те, но для ее ра­бо­ты нуж­ны кое-ка­кие до­полнитель­ные ком­понен­ты. Она мо­жет ра­бо­тать от внут­реннего генера­то­ра им­пуль­сов, но ес­ли под­клю­чить к ней под­хо­дя­щий квар­це­вый генера­тор, она зера­бо­тает го­раз­до бы­ст­рее.

Иногда вам встре­тят­ся мик­ро­схе­мы со внут­ренним генера­то­ром, ко­то­ро­му не ну­жны добавочные кон­ден­са­то­ры. Ос­нов­ная при­чи­на – они де­шев­ле и ра­бо­та­ют не ху­же. Они и вправ­ду ра­бо­та­ют не ху­же, но, со­глас­но раз­ным ис­точникам, силь­ной эко­но­мии не по­лу­чит­ся, да­же ес­ли по­ку­пать их сот­ня­ми. Зато они занима­ют мень­ше мес­та на пла­те, ес­ли это име­ет для вас зна­чение. В лю­бом слу­чае, ме­ж­ду вы­во­да­ми 9 и 10 ATmega168/328 нуж­но под­клю­чить осцил­ля­тор или квар­це­вый генера­тор и кон­ден­са­то­ры.

У мик­ро­кон­тол­ле­ра так­же есть вы­де­лен­ная линия сбро­са, ко­то­рая всегда при­го­дит­ся, ес­ли что-то пой­дет не так, и на эту линию мож­но по­ве­сить кно­поч­ный пе­ре­клю­ча­тель, как и сде­ла­но в на­стоя­щем Arduino.

Мик­ро­кон­трол­лер сбра­сы­ва­ет­ся, когда сиг­нал на этой линии пе­ре­хо­дит в «ноль», т. е. со­еди­ня­ет­ся с зем­лей. Да­же ес­ли мы не на­ве­сим здесь кноп­ку, нуж­но до­ба­вить по­вы­шаю­щий ре­зи­стор, что­бы зна­чение на вы­во­де не «пла­ва­ло» и не при­во­ди­ло к слу­чай­ным сбро­сам.

Для это­го доста­точ­но под­клю­чить ре­зи­стор со­про­тив­лением 10 кОм ме­ж­ду этим вы­во­дом и плю­со­вым вы­во­дом ис­точника пи­тания. К то­му же эта схе­ма не по­влия­ет на ра­бо­ту кноп­ки, ес­ли мы за­хо­тим ее до­ба­вить.

Хо­ти­те верь­те, хо­ти­те нет, но те­перь доста­точ­но лишь за­ста­вить ATmega ра­бо­тать, и наш Arduino поч­ти го­тов. Что­бы он стал бо­лее уз­на­ва­ем и, что бо­лее важ­но, до­пускал про­вер­ку, до­ба­вим несколь­ко све­то­дио­дов.

В стан­дарт­ном Arduino на циф­ро­вом вы­во­де 13 есть све­то­ди­од, ко­то­рый очень час­то ис­поль­зу­ет­ся в схе­мах-при­ме­рах, в том чис­ле в про­стей­шей – «Ми­гание [Blink]»; с ее по­мо­щью так­же лег­ко оп­ре­де­лить, ра­бо­та­ет Arduino или нет.

Циф­ро­вой вы­вод 13 с кор­пу­са Arduino ухо­дит на вы­вод 19 са­мой мик­ро­схе­мы, по­это­му в об­ычном слу­чае мы мог­ли бы под­клю­чить ту­да све­то­ди­од и то­коо­граничи­ваю­щий ре­зи­стор око­ло 270 Ом. Од­на­ко у немно­гих вы­во­дов мик­ро­схе­мы ATmega есть толь­ко од­но на­зна­чение. У вы­во­да 19 их то­же два – он вы­сту­па­ет как по­сле­до­ва­тель­ная линия син­хро­сиг­на­ла при «про­грам­ми­ро­вании в сис­те­ме [In System programming – ISp]». Этим мы на­вер­ня­ка восполь­зу­ем­ся, по­это­му нуж­но убе­дить­ся, что наш све­то­ди­од не по­ме­ша­ет нам. При по­вы­шении со­про­тив­ления токо­о­граничи­ваю­ще­го ре­зи­сто­ра до 1–47 кОм боль­шин­ст­во све­то­дио­дов все еще долж­ны го­реть, к то­му же от­во­д то­ка будет не настолько велик, чтобы по­влия­ть на сиг­на­лы для про­грам­ми­ро­вания схе­мы.

Про­грам­ми­ро­вание ATmega168/328

Те­перь у нас есть нечто вро­де Arduino, и оста­лось ра­зо­брать­ся с тем, как мы бу­дем его про­грам­ми­ро­вать. Тут есть три ва­ри­ан­та. У на­стоя­ще­го Arduino есть по­сле­до­ва­тель­ный USB-ин­тер­фейс. Это очень удоб­но, но труд­но реа­ли­зу­ет­ся на ма­ке­те или на пе­чат­ной пла­те, ес­ли вы взду­мае­те ее изготовить, так как ин­тер­фейс­ные мик­ро­схе­мы очень слож­но па­ять вруч­ную. Мо­же­те восполь­зо­вать­ся пе­ре­ход­ной пла­той от та­ких про­из­во­ди­те­лей, как Adafruit (www.adafruit.com) со схе­мой по­сле­до­ва­тель­но­го ин­тер­фей­са и USB-разъ­е­мом на неболь­шой пла­те, ко­то­рую удоб­но под­клю­чить на ма­кет или к стан­дарт­но­му разъ­е­му.

(thumbnail)
На ма­ке­те нель­зя вос­соз­дать разъ­ем ISP, но го­раз­до про­ще рас­по­ло­жить нуж­ные кон­так­ты в ряд, что­бы за­тем на­пря­мую со­еди­нить их с 6-кон­такт­ным разъ­е­мом ка­бе­ля.
(thumbnail)
На сай­те Arduino есть пре­крас­ное ру­ко­во­дство по ис­поль­зо­ва­нию Arduino в ка­че­ст­ве про­грам­ма­то­ра, со ссыл­ка­ми на со­от­вет­ст­вую­щие схе­мы.

Вто­рой ва­ри­ант – восполь­зо­вать­ся про­грам­ма­то­ром, пред­на­зна­чен­ным для ра­бо­ты с ин­тер­фей­сом ISP. Су­ще­ст­ву­ет несколь­ко мо­де­лей, но, по­жа­луй, луч­шая из них – USBTiny (опять же, раз­ра­бо­тан­ная Adafruit и ши­ро­ко рас­про­странен­ная). Этот про­грам­ма­тор прост, недо­рог, его лег­ко под­клю­чить к ком­пь­ю­те­ру, и он под­дер­жи­ва­ет раз­лич­ные уст­рой­ст­ва Atmel, а не толь­ко от­дель­ные мик­ро­схе­мы, ис­поль­зуе­мые в Arduino.

Тре­тий ва­ри­ант – про­грам­ми­ро­вать Arduino с по­мо­щью самого Arduino. Это мо­жет по­ка­зать­ся стран­ным, по­ка вы не пой­ме­те, что все эти про­грам­ма­то­ры «оп­ре­де­лен­но­го на­зна­чения» по су­ти пред­став­ля­ют со­бой тот же Arduino, раз­ве что ис­поль­зу­ют бо­лее про­стые мик­ро­кон­трол­ле­ры. (См. врез­ку «Про­грам­ма­тор Arduino».)

В пер­вом ва­ри­ан­те мож­но восполь­зо­вать­ся ПО для Arduino как обыч­но; во вто­ром и треть­ем ва­ри­ан­те при­дет­ся вой­ти в мир команд­ной стро­ки и AVRdude.

(thumbnail)
Спе­ци­аль­ный про­грам­ма­тор вро­де USBTiny — пре­крас­ное вло­же­ние средств, ес­ли вы зай­ме­тесь этим серь­ез­но.

На са­мом де­ле AVRdude ис­поль­зу­ет­ся са­мой сре­дой раз­ра­бот­ки Arduino. Ка­ж­дый раз при на­жа­тии кноп­ки Upload (За­гру­зить) в ре­дак­то­ре Arduino про­ис­хо­дят сле­дую­щие дей­ст­вия:

  • Файл «при­ме­ра» пре­об­ра­зу­ет­ся в стан­дарт­ный код на C с вклю­чением биб­лио­те­ки ‘Wiring’ и необ­хо­ди­мых за­го­лов­ков функ­ций.
  • За­тем этот файл ком­пи­ли­ру­ет­ся avr-gcc, ком­пи­ля­то­ром Gnu для мик­ро­про­цес­со­ра AVR.
  • Ском­пи­ли­ро­ван­ный файл лин­ку­ет­ся, и соз­да­ет­ся стан­дарт­ный файл ELF.
  • Файл ELF пре­об­ра­зу­ет­ся в фор­мат ‘Intel Hex’.
  • Файл в ше­ст­на­дца­те­рич­ном фор­ма­те от­прав­ля­ет­ся в мик­ро­схе­му че­рез AVRdude.

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

Под­роб­ный ре­жим

Ес­ли при на­жа­тии кноп­ки Verify (Про­ве­рить) в IDE удер­жи­вать кла­ви­шу Shift, про­грам­ма пе­ре­клю­чит­ся в под­роб­ный ре­жим, и на нижней панели бу­дут по­яв­лять­ся со­об­щения о про­ис­хо­дя­щем.

Сре­ди них бу­дет ин­фор­ма­ция о рас­по­ло­жении вре­мен­но­го ше­ст­на­дца­те­рич­но­го фай­ла, ском­пи­ли­ро­ван­но­го из ва­шей про­грам­мы – по­то­му что в про­цес­се про­вер­ки на са­мом де­ле вы­пол­ня­ют­ся все эта­пы сбор­ки, кро­ме по­следнего: за­груз­ки про­шив­ки в схе­му. Файл бу­дет со­хранен в ка­та­ло­ге для вре­мен­ных фай­лов, обыч­но где-то в /tmp – бо­лее под­роб­ную ин­фор­ма­цию см. во врез­ке «Шаг за ша­гом».

По­лу­чив ше­ст­на­дца­те­рич­ный файл, мож­но за­гру­зить его в схе­му с по­мо­щью AVRdude. Ес­ли у вас есть пе­ре­ход­ная пла­та для USB или вы хо­ти­те, что­бы схе­ма бы­ла Arduino-со­вмес­ти­мой, так­же непло­хо уста­но­вить за­груз­чик. Оно вся­ко не по­вре­дит – немно­го мес­та за­груз­чик отнимет, но по­зво­лит лег­ко об­ме­нять мик­ро­схе­му с на­стоя­щим Arduino.

(thumbnail)
Имен­но с по­мо­щью ПО AVRdude Arduino IDE про­грам­ми­ру­ет мик­ро­схе­мы.

Пре­ж­де все­го убе­дим­ся, что AVRdude ра­бо­та­ет и ви­дит про­грам­ма­тор и мик­ро­схе­му. Для это­го нуж­но пе­ре­дать ему два па­ра­мет­ра. Пер­вый – на­звание мик­ро­схе­мы, ко­то­рую мы хо­тим за­про­грам­ми­ро­вать. Про­грам­ма под­дер­жи­ва­ет боль­шой на­бор мик­ро­кон­трол­ле­ров, но для Arduino вы ско­рее все­го бу­де­те ис­поль­зо­вать m168 и m328p. Про­грам­ма­тор – та про­грам­ма, с по­мо­щью ко­то­рой ин­фор­ма­ция за­пи­сы­ва­ет­ся в мик­ро­схе­му – на­при­мер, usbtiny, arduino или лю­бая дру­гая, ко­то­рая у вас есть (ин­фор­ма­цию о под­дер­жи­вае­мых уст­рой­ст­вах см. на сай­те AVRdude – http://savannah.nongnu.org/projects/avrdude). 

 
$ avrdude -p m168 -c usbtiny

На эк­ране долж­но поя­вить­ся со­об­щение на несколь­ко строк, что уст­рой­ст­­во го­то­во. Ес­ли возникнет ошиб­ка «уст­рой­ст­­во не най­де­но», ско­рее все­го де­ло в пра­вах досту­па (по­про­буй­те сно­ва за­пустить ко­ман­ду от имени root). Ошиб­ка «инициа­ли­за­ция за­вер­ше­на неудач­но» оз­на­ча­ет, что про­грам­ма­тор ра­бо­та­ет нор­маль­но, но не мо­жет най­ти мик­ро­схе­му, ко­то­рую нуж­но за­про­грам­ми­ро­вать – про­верь­те под­клю­чение и рас­по­ло­жение ка­бе­лей.

За­груз­чи­ки для раз­лич­ных мик­ро­схем, ис­поль­зуе­мых в Arduino, хра­нят­ся в ва­шей сис­те­ме вме­сте с ПО Arduino. В за­ви­си­мо­сти от ис­поль­зуе­мо­го ди­ст­ри­бу­ти­ва, они бу­дут на­хо­дить­ся в ка­та­ло­ге вро­де /usr/share/arduino/hardware/arduino/bootloaders.

Энер­гонеза­ви­си­мые ре­ги­ст­ры

Когда все за­ра­бо­та­ет, мож­но за­гру­зить за­груз­чи­ки и при­ло­жение. Пер­вым де­лом за­да­дим зна­чения «пре­до­храните­лей» (о них осо­бо не бес­по­кой­тесь – это на­бор энер­гонеза­ви­си­мых ре­ги­ст­ров, управ­ляю­щих спе­ци­аль­ны­ми воз­мож­но­стя­ми мик­ро­схем ATmega, в том чис­ле за­щи­той за­груз­чи­ка):

$ avrdude -p m168 -c usbtiny -e -u -U lock:w:0x3f:m -U efuse:w:0x00:m -U hfuse:w:0xDD:m -U lfuse:w:0xFF:m

Па­ра­метр -e сти­ра­ет ин­фор­ма­цию в мик­ро­схе­ме, а па­ра­метр -u по­зво­ля­ет за­дать зна­чения «пре­до­храните­лей». За па­ра­мет­ром -U сле­ду­ют на­бо­ры зна­чений в фор­ма­те: об­ласть па­мя­ти, ин­ди­ка­тор опе­ра­ции – чтение/запись или про­вер­ка, за­гру­жае­мое зна­чение или файл и фор­мат фай­ла. Это немно­го на­гляднее, когда мы за­гру­жа­ем один файл, на­при­мер, на­ше при­ло­жение: 

$ avrdude -p m168 -c usbtiny -v -U flash:w:Blink.cpp.hex:i

Так­же нуж­но за­гру­зить за­груз­чик и ус­та­но­вить бло­ки­ров­ку его пе­ре­за­пи­си при об­нов­ле­нии при­ло­же­ния в бу­ду­щем: 

 
$ avrdude -p m168 -c usbtiny -Vv -U flash:w:at168.hex -U lock:w:0x0f:m

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

Шаг за ша­гом: Ком­пи­ли­ру­ем фай­лы в IDE Arduino
(thumbnail)
Загружаем программу. Открываем программу и загружаем файл схемы, который нужно скомпилировать. Нажимаем и удерживаем клавишу Shift для включения подробного режима и нажимаем кнопку проверки кода.
(thumbnail)
Находим выходные файлы На нижней панели находим путь к выходному файлу. Обычно он помещается где-то в каталоге /tmp. Зайдя туда из файлового менеджера, вы найдете все нужные файлы.
(thumbnail)
Загружаем файл с AVRdude Файл с именем <name>.cpp.hex – это файл вашей схемы, скомпилированный для контроллера ATmega и сохраненный в формате Intel Hex. Этот файл можно загрузить в микросхему с помощью AVRdude.
Источник — «http://wiki.linuxformat.ru/wiki/index.php?title=LXF156:Arduino&oldid=17026»
Персональные инструменты
купить
подписаться
Яндекс.Метрика