Урок 21. BASCOM-AVR и Arduino
Не так давно я заинтересовалась популярной платформой для разработки электронных устройств, это – Arduino. Сначала эта платформа мне очень понравилась ввиду её простоты, универсальности и удобства. Свою написанную программу можно оперативно загрузить в микроконтроллер по COM или USB порту, не прибегая к помощи программатора.
Я собрала себе клон Arduino под названием FreeduinoMax232. И начала изучать для себя невиданную среду программирования Processing, начала писать на ней простенькие программки для мигания светодиодами и прочими вещами. Но моя радость была не долгой.
Во-первых, потому что для меня Processing жутко неудобная среда и язык программирования C в ней мне не по душе. Во-вторых, размер программ (скетчей) написанных в Processing жутко большой, например программа, которая просто мигает светодиодом, занимает 890 байт Flash памяти микроконтроллера.
Это много, и с этим можно сразу забыть маленькие микроконтроллеры серии Attiny. В итоге, приятные впечатления у меня остались только от самой платы.
Моя самодельная плата Arduino:
Для программирования микроконтроллеров мне очень нравится среда BASCOM-AVR, так как она достаточно быстрая, удобная и имеет массу приятных вещей. И я задумалась, а как бы подружить плату Arduino и BASCOM-AVR. Именно про это я и расскажу в этой статье.
Начиная с версии 2.0, в BASCOM-AVR включена поддержка Arduino, для использования его как программатора, который программирует сам себя. Давайте разберемся, как нам программировать Arduino из BASCOM-AVR. Для начала запустим BASCOM-AVR и пройдём в меню настроек по цепочке Options – Programmer, вот так:
Далее увидим следующую картину:
Здесь, в выпадающем списке сверху, где “Programmer” нужно выбрать “ARDUINO”. Также в выпадающем списке “COM-port” выберите порт к которому у вас подключена плата Arduino. В поле “BAUD” выберите “19200”. Всё это уже показано на скрине выше.
После установки всех этих настроек нажмите кнопку “Ok”. Теперь можно писать программу и прошивать её в плату! Для тестирования, давайте напишем классическую “мигалку” светодиода подключённого к PORTB.
5 микроконтроллера (на платах Arduino там уже есть светодиод под названием L).
Исходный код программы:
$regfile = “m8def.dat”
$crystal = 16000000 Config Portb.5 = Output Do Portb.5 = 1
Wait 1
Portb.5 = 0
Wait 1
Loop End
После написание программы откомпилируем её, для этого пройдем по цепочке Program – Compile или-же просто нажмём клавишу F7. После компиляции программы можно прошивать её в нашу Arduino, пройдём по цепочке Program – Send to chip – Program.
И увидим окно программы программатора:
Теперь чтобы прошить нашу программу остался один шаг, это пройти по цепочке Chip – Write buffer into chip, или нажать на следующею кнопку:
После этого начнётся прошивка Arduino, при этом светодиоды TX и RX на плате будут быстро мигать. После прошивки, внизу окна, где техническая информация появятся сообщения:
Поздравляю! Мы успешно прошили плату Arduino из BASCOM-AVR, мы их подружили!
Светодиод L на плате должен весело мигать:
Кстати, размер программы “мигалки” написанной в BASCOM-AVR составил всего лишь 192 байта, намного меньше и лучше чем в Processing, правда?
Этот метод прошивки можно использовать на всех платах Arduino и их клонах. Но помните про распиновку выводов, BASCOM-AVR знает только “настоящие” порты и пины микроконтроллеров, не “Ардуиновские”! В файлах к статье вы можете найти исходник и файл прошивки программы “мигалки”.
Прикрепленные файлы:
Источник: http://cxem.net/mc/mc248.php
Управление реле ардуино: скетч
В этой статье приведены разные варианты управления реле в скетчах ардуино. Примеры тестировались на Arduino Uno, но они могут быть легко применимы для работы на других платах Arduino: Uno, Mega, Nano.
Простой вариант скетча управления реле
Схема подключения
В данном примере используется стандартный модуль реле ардуино, на котором уже установлены все необходимые элементы для подключения к .
Схема подключения очень проста: модуль реле присоединяется к 5 пину платы Ардуино.
При этом для простоты мы можем даже не присоединять реальную нагрузку — реле будет щелкать при каждом изменении состояния, мы услышим эти щелчки и будем понимать, что скетч работает.
Скетч для работы с реле
/* * Скетч для управления реле с помощью ардуино * Используем реле SONGLE SRD-05VDC * Реле ОТКРЫВАЕТСЯ при подаче низкого уровня сигнала (LOW) на управляющий пин. * Реле ЗАКРЫВАЕТСЯ при подаче высокого уровня сигнала (HIGH) на управляющий пин. * * В данном примере мы просто открываем и закрываем реле раз в 5 секунд.
* * PIN_RELAY содержит номер пина, к которому подключено реле, которым мы будем управлять * * В функции setup устанавливаем начальное положение реле (закрытое) * Если к реле будет подключена нагрузка(например, лампочка), то после запуска скетча она будет включаться и выключаться каждые 5 секунд * * Для изменения периода мигания нужно изменить параметр функции delay(): поставив 1000 миллисекунд, выполучите 1 секунду задержки * * В реальных проектах реле включается в ответ на обнаружение каких-либо внешних событий через подключение датчиков * */ #define PIN_RELAY 5 // Определяем пин, используемый для подключения реле // В этой функции определяем первоначальные установки
void setup()
{ pinMode(PIN_RELAY, OUTPUT); // Объявляем пин реле как выход digitalWrite(PIN_RELAY, HIGH); // Выключаем реле – посылаем высокий сигнал
}
void loop()
{ digitalWrite(PIN_RELAY, LOW); // Включаем реле – посылаем низкий уровень сигнала delay(5000); digitalWrite(PIN_RELAY, HIGH); // Отключаем реле – посылаем высокий уровень сигнала delay(5000);
}
Скетч управления реле с датчиком движения
В реальных проектах изменение состояния реле должно происходить в ответ на какую то реакцию среды. Например, в ответ на сигнал сработавшего датчика движения можно включить свет, замкнув цепь с помощью реле. В данном скетче мы рассмотрим такой вариант подключения.
Схема подключения реле
Следует понимать, что в реальных проектах обходятся вообще без ардуино — просто подключая сигнальный выход датчика к реле.
Пример скетча
В данном примере мы добавим в цикл loop проверку состояния PIR датчика с помощью функции digitalRead (). Если мы получаем HIGH, то это означает сработку датчика и мы выполняем действие — включаем реле. Если к нему присоединить лампочку, то она загорится. Но, как и в прошлом примере, можно просто послушать щелчки.
/* Скетч для управления реле ардуино с помощью PIR датчика PIN_RELAY содержит номер пина, к которому подключено реле, которым мы будем управлять PIN_PIR содержит номер пина с подключенным PIR-сенсором В функции setup устанавливаем начальное положение реле (закрытое) В теле функции loop проверяем наличия высокого уровня сигнала от датчика с помощью функции digitalRead Для отладки текущее значение датчика выводим в окно монитора порта
*/ #define PIN_RELAY 8 // Определяем пин, используемый для подключения реле
#define PIN_PIR 5 // Определяем пин, используемый для подключения PIR-датчика // В этой функции определяем первоначальные установки
void setup()
{ Serial.begin(9600); pinMode(PIN_RELAY, OUTPUT); // Объявляем пин реле как выход digitalWrite(PIN_RELAY, HIGH); // Выключаем реле – посылаем высокий сигнал
}
void loop()
{ int val = digitalRead(PIN_PIR); // Считваем значение с датчика движения в отдельную переменную if (val == HIGH) { Serial.println(“Датчик сработал”); digitalWrite(PIN_RELAY, LOW); // Включаем реле – посылаем низкий уровень сигнала } else { digitalWrite(PIN_RELAY, HIGH); // Отключаем реле – посылаем высокий уровень сигнала } delay(1000); // Проверяем значения один раз в секунду.
}
Источник: https://ArduinoMaster.ru/program/upravlenie-rele-arduino-sketch/
Урок 4. Использование ШИМ в AVR микроконтроллерах
ШИМ (PWM) — широтно-импульсная модуляция. Не нужно пугаться данного термина. Это всего навсего способ регулирования напряжения. Допустим подсветка монитора горит слишком ярко, вы меняете яркость. А что же происходит в этот момент на самом деле?
Представим себе, что подсветка монитора это несколько светодиодов. Питается все это дело от постоянного напряжения. Но вот нам понадобилось уменьшить яркость монитора. Логично ответить, что это можно сделать переменным резистором. На маленьких токах — возможно. Но на больших, резистор будет сильно греться. Сильно возрастут габариты, потери, энергопотребление.
Поэтому люди придумали схему на транзисторах, которая делает из постоянного напряжения пульсирующее. Оказывается, пульсирующее напряжение, в зависимости от заполнения периода будет эквивалентно постоянному напряжению. Т.е. если в течение периода напряжение 50% времени было включено, 50% выключено, то эквивалент постоянного напряжения будет равен 50% от номинального.
В цифрах это просто — было 5В постоянного напряжения прогнали через ШИМ — получили 2,5В. Если заполнение импульса равно 75%, то эквивалентное постоянное напряжение будет 3,75В. Думаю идея понятна.
Теперь приступим к практической реализации. Будем при помощи микроконтроллера изменять заполнение от 0 до 100%, потом от 100% до нуля. Конечный результат должен выглядеть так:
Чтобы было более наглядно, подключим светодиод. В результате у нас будет плавно включаться и отключаться светодиод.
Запускаем наш любимый CodeVision. Создаем проект при помощи мастера. В разделе таймеров (Timers), выбираем Timer 2 и выставляем настройки как на рисунке.
Если попробовать сгенерировать проект, то прога может ругнуться. Соглашаемся, ведь у нас нога 3 порта В должна быть настроена как выход.
Приводим код к следующему виду:
| 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 |
#include void main(void) { PORTB=0x00; DDRB=0x08; // Timer/Counter 2 initialization ASSR=0x00; TCCR2=0x6C; TCNT2=0x00; OCR2=0x00; TIMSK=0x00; while (1) { }; } |
#include void main(void) { PORTB=0x00; DDRB=0x08; // Timer/Counter 2 initialization ASSR=0x00; TCCR2=0x6C; TCNT2=0x00; OCR2=0x00; TIMSK=0x00; while (1) { }; }
Уделим внимание строке OCR2=0x00; Эта переменная как раз и отвечает за величину заполнения импульса. Изменяется данная величина от 0 до 255(0хFF), т.е. 255 соответствует 100% -му заполнению (постоянный ток). Следовательно, если нужно 30% заполнение (255/100)*30=77. Далее 77 переводим в шестнадцатеричную систему OCR2=0x4D;
TCCR2=0x6C; Изменяя данную величину мы можем регулировать частоту ШИМ. Величина частоты работы ШИМ кратна частоте, на которой работает микроконтроллер.
В проекте использована частота микроконтроллера 8 МГц, частоту ШИМ использовали 125кГц, следовательно делитель равен 8/125=64
0x6C в двоичной системе счисления 1101100, открываем даташит на Atmega8 и видим описание регистра TCCR2, так вот 1101100 последние цифры 100 и отвечают за выбор частоты работы ШИМ
Приступим непосредственно к программе:
| 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 |
#include #include void main(void) { PORTB=0x00; DDRB=0x08; ASSR=0x00; TCCR2=0x6C; TCNT2=0x00; OCR2=0x00; TIMSK=0x00; while (1) { while(OCR20x00) { OCR2=OCR2-0x01; delay_ms(5); } }; } |
#include #include void main(void) { PORTB=0x00; DDRB=0x08; ASSR=0x00; TCCR2=0x6C; TCNT2=0x00; OCR2=0x00; TIMSK=0x00; while (1) { while(OCR20x00) { OCR2=OCR2-0x01; delay_ms(5); } }; }
Код прост до безобразия: сначала в цикле увеличиваем заполнение от 0 до 255(ff), потом уменьшаем от 255 до 0. И напоследок видосик, как это все должно работать. Успехов в изучении)
Источник: http://avr-start.ru/?p=367
Урок по arduino 1 – Ваша первая “Hello World!” программа на arduino
Для первого урока нам ничего не нужно кроме самой Arduino и usb кабеля к ней.Как не банально это будет звучать, но давайте скажем с помощью Arduino “Hello World!”. С этого простого эксперимента мы сделаем свой первый шаг в мир Arduino.
Для урока нам понадобится :
- Arduino uno контроллер
- USB кабель (в большинстве случае он идет в комплекте с контроллером)
Для начала нам нужно подключить Arduino к компьютеру, а затем написать в данной среде код программы “Hello World!”. Копируем его и вставляем в ранее установленную IDE.
int val; // Задаем переменную val для отслеживания нажатия клавиши
int ledpin = 13; // задаем цифровой интерфейс ввода/вывода 13 – это наш светодиодvoid setup (){ Serial.begin (9600); // Задаем скорость обмена com-порта 9600 pinMode (ledpin, OUTPUT); // Задаем ledpin = 13 как интерфейс вывода информации}void loop (){ val = Serial.read (); // Считываем команду посланную с компьютера через консоль IDE Arduino if (val == 'R') // Задаем букву условие на букву “R”, при нажатии которой в консоли будет зажигался светодиод и появится строка “Hello World!”{digitalWrite (ledpin, HIGH); // Включаем светодиод на 13 выходе платыdelay (500);digitalWrite (ledpin, LOW); // Выключаем светодиод на 13 выходе платыSerial.println (“Hello World!”); // Пишем в консоль “Hello World!”}
}
Или вы можете его залить в ардуино прямо с браузера из ниже предложенного окна. При этом предварительно нужно установить драйвера для вашей платы.
Данные код ждет когда на виртуальный com порт arduino будет подан сигнал в виде буквы “R”, после этого зажигается встроенный светодиод на плате (выход № 13 платы) на 2000мс (2секунды), а потом в мониторе порта arduino UNO возвращает нам надпись “Hello World!”
Разберем код программы.
В первых двух строках задаются наши переменные val и ledpin, причем второй переменной сразу присвоено значение 13 – это номер выхода на котором находится встроенный светодиод на плате.
Далее в обязательной процедуре void setup () командой Serial.begin (9600) мы задаем скорость обмена данными с нашей платой.
Пока мы не планируем передавать большие объемы данным, поэтому зададим небольшую скорость 9600, что положительно скажется на стабильности обмена данными с компьютером.
Команда pinMode (ledpin, OUTPUT) указывает микроконтроллеру, что вывод 13 (переменная ledpin) предназначен для вывода информации, в нашем случае мы будем включать и выключать напряжение на светодиоде.
Основной код программы выполняется в обязательной процедуре void loop (), она по кругу до бесконечности выполняет код внутри нее.
Считываем данные с com порта – val = Serial.read ();Если com порта пришла буква R – if (val == 'R')
то
Источник: https://AutoHome.org.ua/arduino-lessons/58-arduino-lesson-1-hello-world
Установка дополнительных плат в Arduino IDE | РОБОТОША
Начиная с Arduino IDE 1.6.2 по умолчанию ядром программы поддерживаются только AVR-платы Arduino. Некоторые платы Arduino требуют использования дополнительных функций, которые должны быть установлены в ядро программы.
Одним из примеров является Arduino Due, которая использует ARM/SAM микроконтроллеры. Для того была возможность, используя Arduino IDE, программировать Arduino Due, необходимо установить SAM-ядро с помощью Boards Manager.
В этом примере мы установим ядро, необходимое для платы Arduino Due.
Выбираем меню → →
Откроется окно Менеджера плат, в котором вы увидите список установленных и доступных плат. Выберем ядро SAM, требуемую версию (как и в случае с Менеджером библиотек может быть доступна лишь одна версия, поэтому выпадающего списка с перечнем доступных версий может и не быть) и жмем .
По завершению процесса установки (который может занять достаточно продолжительное время) статус ядра SAM станет INSTALLED. Теперь плата Arduino Due станет доступна в меню → .
Ручная установка плат
Также имеется возможность добавления плат в ручном режиме. Этот метод работает на Arduino IDE версии 1.6.1 и на версии 1.6.3. Для версии IDE 1.6.2 метод не работоспособен (баг исправлен в релизе 1.6.3). Насчет версий ранее 1.6.1 ничего сказать не могу.
Расскажу на примере плат компании Adafruit.
Сначала скачиваем файлы описания для плат с GitHub-репозитория Adafruit или по ссылке ниже (на GitHub, возможно, будет более свежая версия этого архива).
Если вы скачали архив с Github, то распакуйте архив и переменуйте получившуюся папку из Adafruit_Arduino_Boards-master в Adafruit_Arduino_Boards.
Внутри этой папки вы обнаружите две подпапки:
- , также содержащую подпапки и
- , в которой находятся драйвера для
Далее необходимо найти подпапку в папке с Arduino IDE. Для Windows и Linux это будет папка, в которую было установлено приложение.
В Mac OS папка скрыта внутри пакета приложения. Для того, чтобы найти ее делаем правый клик на приложении Arduino IDE и выбираем
Переходим внутри по вложенным подпапкам → и находим там папку .
Теперь нужно внимательно объединить содержимое папки c аналогичной папкой из скаченного нами ранее и распакованного архива с описанием плат с сайта Adafruit. Нужно удостовериться в том, что вы переписали конфликтующие файлы (в данном случае avrdude.conf). После всех операций папка приложения Arduino IDE будет иметь следующую структуру:
Если вы работаете в Windows, то вам необходимо будет переписать еще и папку .
Если все сделано правильно, то новые платы появятся в меню → в Arduino IDE.
Платы на базе микроконтроллеров ATTiny
Один из моих читателей — Павел Пащенко любезно поделился файлами описаний к микроконтроллерам серии ATTiny. Cпасибо, Павел!
| Category: | Programs |
| Date: | 08.04.2015 |
Установка аналогична описанной выше.
Получившийся у Павла результат в Windows:
Платы на базе микроконтроллера Atmega8
Для микроконтроллеров Atmega8 с внешним кварцем на 8 МГц и без загрузчика, в файл необходимо добавить следующие строки:
| ##############################################################atmega8.name=ATmega8 (no bootloader 8MHz ext)atmega8.upload.protocol=arduinoatmega8.upload.tool=usbaspatmega8.upload.maximum_size=7680atmega8.upload.speed=115200atmega8.bootloader.low_fuses=0xFFatmega8.bootloader.high_fuses=0xD9atmega8.bootloader.unlock_bits=0x3Fatmega8.bootloader.lock_bits=0x0Fatmega8.build.mcu=atmega8atmega8.build.f_cpu=8000000Latmega8.build.core=arduinoatmega8.build.variant=standard |
Платы на базе м/к ATmega128
Подробности в статье ATmega128 + Arduino IDE + USBasp
Источник: http://robotosha.ru/arduino/install-core-arduino-ide.html
Arduino UNO — Энкодер. Урок 6
Читать все новости ➔
В очередном уроке мы рассмотрим работу Arduino с энкодером (который служит для преобразования угла поворота в эл. сигнал). С энкодера мы получаем 2 сигнала (А и В), которые противоположны по фазе.
В данном уроке мы будем использовать энкодер фирмы SparkFun COM-09117, который имеет 12 положений на один оборот (каждое положение 30°).
На приведенной ниже диаграмме вы можете видеть, как зависят выход А и В друг от друга при вращении энкодера по часовой или против часовой стрелки.
Каждый раз, когда сигнал А переходит от положительного уровня к нулю, мы считываем значение выхода В. Если В в этот момент находится в положительном состоянии, значит энкодер вращается по часовой стрелке, если В нуль, то энкодер вращается против часовой стрелки.
Считывая оба выхода, мы при помощи МК можем определить направление вращения, и при помощи подсчета импульсов с А выхода – угол поворота. Конечно можно пойти еще дальше и при помощи вычисления частоты, можно определить насколько быстро происходит вращение энкодера.
Как вы видите, энкодер имеет много преимуществ по сравнению с обычным потенциометром.
Используя энкодер мы будем управлять яркостью LED светодиода при помощи ШИМ выхода. Для считывания данных энкодера мы будем использовать простейший метод, основанный на программных таймерах, которые мы изучали в третьем уроке.
Как было сказано выше, мы будем использовать энкодер sparkfun. Первое, что необходимо сделать, это определить как часто нам нужно обращаться к выходам энкодера для считывания значений. Итак, представим себе, что в лучшем случае, мы можем повернуть ручку энкодера на 180° за 1/10 сек, т.е.
это будет 6 импульсов за 1/10 сек или 60 импульсов в секунду. В реальности быстрее вращать не сможете. Т.к. нам необходимо отслеживать все полупериоды, то частота должна быть минимум 120 Герц. Для полной уверенности, давайте примем 200 Гц. (Примечание: т.к.
у нас механический энкодер, то возможен дребезг контактов, а низкая частота позволяет отфильтровывать дребезг).
По сигналам программного таймера нам необходимо постоянно сравнивать текущее значение выхода А энкодера с предыдущим значением. Если состояние изменилось от положительного к нулю, то мы проверяем значение выхода В и смотрим положительное оно или нет. В зависимости от полученного результата мы увеличиваем или уменьшаем счетчик значения яркости светодиода.
Программа для данного урока приведена ниже. Она построена на базе предыдущего урока Fade, где использовалась функция millis() для задания временных интервалов. Временной интервал у нас будет 5 мс (200 Гц)
| 12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849 | /*** Энкодер** Для управлением яркостью LED используется энкодер Sparkfun*/int brightness = 120; // яркость LED, начинаем с половиныint fadeAmount = 10; // шаг изменения яркости LEDunsigned long currentTime;unsigned long loopTime;constint pin_A = 12; // pin 12constint pin_B = 11; // pin 11unsigned char encoder_A;unsigned char encoder_B;unsigned char encoder_A_prev=0;void setup() { // declare pin 9 to be an output: pinMode(9,OUTPUT); // устанавливаем pin 9 как выход pinMode(pin_A,INPUT); pinMode(pin_B,INPUT); currentTime =millis(); loopTime = currentTime;}void loop() { currentTime =millis(); if(currentTime >= (loopTime + 5)){// проверяем каждые 5мс (200 Гц) encoder_A =digitalRead(pin_A); // считываем состояние выхода А энкодера encoder_B =digitalRead(pin_B); // считываем состояние выхода А энкодера if((!encoder_A) && (encoder_A_prev)){ // если состояние изменилось с положительного к нулю if(encoder_B) { // выход В в полож. сост., значит вращение по часовой стрелке // увеличиваем яркость, не более чем до 255 if(brightness + fadeAmount = 0) brightness -= fadeAmount; } } encoder_A_prev = encoder_A; // сохраняем значение А для следующего цикла analogWrite(9, brightness); // устанавливаем яркость на 9 ножку loopTime = currentTime; } } |
Оригинал
cxem.net
Возможно, Вам это будет интересно:
Источник: http://meandr.org/archives/13128
Программирование Arduino – Физика процесса
Наша свежеслепленная , как и компьютер без софта – просто железо. Чтобы плата ожила и начала делать хоть что-нибудь нужна программа или как часто говорят – прошивка.
Написать её под ардуину можно на разных языках — ассемблере, си, паскале, хоть на бейсике, но, обычно, пишут на , из под личной ардуиновской среды разработки — и загружают (прошивают) оттуда же.
Как писать прошивки (у ардуино они называется – скетчи) нам подробно уважаемый admin, а тем кто захочет разобраться с физическим процессом запихивания нашего виртуального творчества в плату поможет (надеюсь) эта серия статей.
Загрузить прошивку в МК семейства Mega (а именно такая стоит в ардуине) можно разными способами: Последовательным программатором по интерфейсу SPI Через интерфейс JTAG Параллельным («высоковольтным») программатором.
Во всех этих случаях необходим , который надо либо делать, либо где-то покупать (стоят они все прилично), а в ардуино всё шьётся обычным USB-шнурком (ну или com как в случае с хоуммейдовой платой), как же так?! Нет разработчики не стали запихивать на каждую плату по программатору, а использовали одну удобную функцю МК Atmega под названием «самопрограммирование». Если в определённую область памяти программ атмеги прошить специальную программу-загрузчик( далее бутлоадер) то можно заставить её (атмегу) прошивать саму себя по любому имеющемуся на борту интерфейсу – I2C, UART или SPI. В ардуино используется именно UART(com порт практически) — в USB-шных версиях плат стоит преобразователь USB-to-COM (обычно ft232), а на COM-овских — преобразователь уровней COM-to-TTL (max232 или на дискретных транзисторах)
Работает всё это следующим образом – когда Arduino перезагружается — запускается бутлоадер (если он есть). Он посылает импульсы на цифровой вывод 13 (к данному выводу подключён светодиод — он будет мигать) — это означает, что бутлоадер установлен и работает. Далее бутлоадер ждёт команды или данные от компьютера.
Обычно, это скетч, который бутлоадер записывает в flash-память МК. Затем, бутлоадер запускает свежезагруженную программу на выполнение. Если никаких данных не поступает — бутлоадер запускает предыдущую программу, которая была загружена в микроконтроллер. Если же никакой программы нет, то бутлоадер запускает себя снова (цикл повторяется).
Плату мы , , посмотрим что можно в неё загрузить.
Для загрузки скетчей нужен прямой COM-шнурок папа-мама т.е. просто удлинитель — фактически можно воткнуть плату прямо в COM-порт(без шнурка=)
Запускаем ArduinoIDE (кто не в курсе — запускать надо файл run.bat из папки arduino-0015, свежую ArduinoIDE можно скачать ) Выбираем тип нашей платы. . . Выбираем COM-порт. . . .
Выбираем скетч из примеров, например блинк — будем мигать светодиодом- стандартный для МК способ сказать хело волд =). . . . . . . . . . . . . . . .
Будем хоть немного оригинальны — изменим код=) Помигаем внешним светодиодом (13 пином и так бутоладер мигает)int ledPin = 11; // светодид подключим к 11 выходу void setup() // запускается единожды когда стартует скетч { pinMode(ledPin, OUTPUT); // конфигурируем 11 пин как выход } void loop() // будет крутиться в бесконечном цикле { digitalWrite(ledPin, HIGH); // включим светодиод delay(500); // подождём пол секунды digitalWrite(ledPin, LOW); // выключим светодиод delay(500); // подождём пол секунды } скомпилируем всё это дело — жмём на стрелку, ждём, смотрим на надпись внизу — 790байт из 7168байт, доступных для нашего скетчаподадим питание, воткнём шнурок в плату и COM-порт,. . . . . . . . . жмём загрузитьЖдем…Загрузилось=)Втыкаем светодиод в землю и в 11 пин, жмём резет, ждём пока бутлоадер потупит в ожидании нового скетча…мигает!
далее:
Ссылки:
По теме:
книга на русском языке: (PDF 1.3 Mb)
Источник: http://robocraft.ru/blog/arduino/48.html
Загрузка...
