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

LXF156:Arduino

Материал из Linuxformat
Перейти к: навигация, поиск


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

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

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

243518.png
Наш эксперт

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

На этом уро­ке мы уй­дем немно­го в сто­ро­ну от обыч­ных ста­тей, в ко­то­рых мы со­би­ра­ли схе­мы из ком­понен­тов, и со­бе­рем соб­ст­вен­ную пла­ту 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.
Что нам на­до
  • Arduino ИЛИ про­грам­ма­тор ISP, та­кой как USBTiny.
  • За­пас­ной про­цес­сор ATmega168 или 328p.
  • Квар­це­вый ге­не­ра­тор с час­то­той 16 МГц.
  • Ре­гу­ля­тор на­пря­же­ния 7805.
  • Кон­ден­са­то­ры не­об­хо­ди­мой ем­ко­сти и до­пол­ни­тель­ные све­то­дио­ды.

Ра­зо­брав­шись с ис­точником пи­тания, по­ду­ма­ем о мик­ро­схе­ме 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-кон­такт­ным разъ­е­мом ка­бе­ля.
Про­грам­ма­тор Arduino

За­про­грам­ми­ро­вать один Arduino с по­мо­щью дру­го­го до­воль­но про­сто, ес­ли за­гру­зить его нуж­ным ПО – а ском­му­ти­ро­вать про­вод­ни­ки еще про­ще, так как у стан­дарт­но­го Arduino есть разъ­ем ISP. На сай­те Arduino (http://arduino.cc/en/Tutorial/ArduinoISP) есть пре­крас­ные по­ша­го­вые ин­ст­рук­ции по про­грам­ми­ро­ва­нию плат Arduino или Arduino на ма­ке­те та­ким об­ра­зом.

(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.
Идем даль­ше

Когда схе­ма для соб­ст­вен­но­го Arduino го­то­ва, есть несколь­ко ва­ри­ан­тов. Оче­вид­но, ес­ли вам нуж­но несколь­ко схем, со­би­рать их на ма­ке­те – не луч­ший вы­ход. Луч­ше со­брать схе­му на ка­кой-то твер­дой осно­ве, а еще луч­ше – сде­лать пе­чат­ную пла­ту. В Linux есть мно­же­ст­во пре­крас­ных про­грамм для соз­дания пе­чат­ных плат, а го­то­вую пла­ту мож­но ли­бо вы­тра­вить са­мо­му (www.instructables.com/id/Sponge-Ferric-Chloride-Method-Etch-Circuit-Bo), ли­бо восполь­зо­вать­ся спе­ци­аль­ным сер­ви­сом.

Схе­мы са­мих пе­чат­ных плат Arduino доступ­ны в фор­ма­те Eagle. Сис­те­ма про­ек­ти­ро­вания CAD Eagle очень по­пу­ляр­на сре­ди ра­дио­лю­би­те­лей, но не бес­плат­на. В «бес­плат­ной» вер­сии ог­раничен раз­мер из­го­тав­ли­вае­мых плат; впро­чем, для схем Arduino его долж­но быть доста­точ­но. Eagle, по­жа­луй, са­мый про­стой ва­ри­ант – по­то­му что с ним всегда мож­но из­менить фай­лы Arduino, уда­лив ненуж­ное или что-то до­ба­вив. В этом фор­ма­те так­же доступ­но и мно­же­ст­во кло­нов Arduino.
(thumbnail)
Фай­лы пе­чат­ных плат Arduino дос­туп­ны в фор­ма­те CAD Eagle.
Их име­на со­от­вет­ст­ву­ют на­зна­чению, но, на мой взгляд, слиш­ком длин­ны; вы мо­же­те сде­лать ко­пии с име­на­ми по­ко­ро­че.

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

Когда все за­ра­бо­та­ет, мож­но за­гру­зить за­груз­чи­ки и при­ло­жение. Пер­вым де­лом за­да­дим зна­чения «пре­до­храните­лей» (о них осо­бо не бес­по­кой­тесь – это на­бор энер­гонеза­ви­си­мых ре­ги­ст­ров, управ­ляю­щих спе­ци­аль­ны­ми воз­мож­но­стя­ми мик­ро­схем 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.
Персональные инструменты
купить
подписаться
Яндекс.Метрика