Какую функцию надо запустить для проверки кода на ошибки arduino

Отладка программы является жизненно важным элементом при ее разработке. Программы для плат Arduino не являются в этом плане исключением. Процедура программирования плат Arduino достаточно проста, чего нельзя сказать о способах отладки программ, доступных для данной платформы. Одна из причин этого заключается в том, что платформа Arduino не располагает специализированными инструментами отладки программ, хотя в новой Arduino IDE pro такой инструмент все же появился.

В данной статье мы рассмотрим собственные (доступные в Arduino IDE) и внешние инструменты отладки программ для плат Arduino.

Также отладку программ для плат Arduino удобно производить в симуляторе UnoArduSim.

Собственные средства отладки в Arduino IDE

В Arduino IDE есть ряд собственных инструментов, которые можно использовать для отладки программ – это компилятор, монитор последовательного порта (Serial Monitor) и последовательный плоттер (построитель графиков в реальном времени по данным из последовательного порта). А в Arduino IDE Pro уже доступен свой собственный отладчик. Давайте рассмотрим эти инструменты более подробно.

Компилятор

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

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

Монитор последовательного порта

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

Вы можете выводить в окно монитора последовательного порта следующие данные, которые могут пригодиться для отладки программы:

• значения входных контактов (обычно это данные, считываемые с каких либо датчиков);
• значения переменных в программе. По изменению их значений вы можете, например, делать выводы о том, исполняются или нет условные операторы (‘if’) в вашей программе;
• значения выходных контактов (например, значения ШИМ перед подачей их непосредственно на контакт).

Средства отладки в Arduino IDE Pro

Arduino IDE Pro имеет встроенные средства отладки программ, которых нет в обычной Arduino IDE, что делает ее особенно полезной при разработке сложных программ.

К средствам отладки в Arduino IDE Pro относятся:

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

Другими дополнительными функциями Arduino IDE Pro являются отладка в реальном времени, автозаполнение, адаптивный интерфейс и более быстрое время компиляции.

Если рассмотренные в предыдущем разделе статьи собственные средства отладки платформы Arduino вам не помогли найти ошибки в коде программы, то можно попробовать использовать внешние инструменты отладки программ. Далее мы рассмотрим наиболее популярные из этих инструментов.

Visual Micro

Visual Micro – это плагин для Microsoft Visual Studio, который позволяет разрабатывать кросс-платформенные приложения Arduino. Любой код, написанный на Visual Micro и соответствующий спецификациям Arduino, будет одобрен. Поскольку Visual Micro позволяет изменять общий код и библиотеки, он идеально подходит для случаев, когда написание и отладка кода программа производится несколькими участниками (командой разработчиков). Код с нескольких платформ может быть разработан и интегрирован с программным кодом в процессе компиляции. Visual Micro также обеспечивает отладку GDB и отладку фрагментов кода программы, работающих с последовательными портами связи, технологиями Bluetooth и WiFi.

DebugWire

DebugWire – это протокол, разработанный компаний Atmel и позволяющий производить отладку программ, написанных для микроконтроллеров серий ATTiny (ATTiny 13, 85 и др.) и ATmega (ATmega 32/48/88/168/328), без использования интерфейса JTAG, используя только контакт сброса (Reset pin). Компания Atmel не выкладывает документацию протокола debugWIRE в открытый доступ, однако ряд энтузиастов перепроектировали его большие разделы и смогли создать несколько базовых отладчиков на его основе. Протокол DebugWire обеспечивает полный доступ на чтение и запись ко всей памяти микроконтроллеров AVR, а также полный контроль над процессом выполнения программы. Он поддерживает следующие инструменты отладки программ:

• пошаговое выполнение программы (по одной строчке в коде программы);
• выполнение программы до позиции курсора;
• пошаговый выход;
• прерывание работы программы.

Atmel Studio

Atmel Studio IDE — это бесплатная программа, которая обладает весьма неплохими возможностями отладки программ. Atmel Studio позволяет разрабатывать, компилировать и загружать программу в соответствующий микроконтроллер. IDE Atmel Studio, как и Arduino IDE, использует один и тот же код, поэтому вам не нужно изучать новый язык программирования, чтобы использовать Atmel Studio.

Atmel Studio обладает высокой адаптивностью и поддерживает чертежи .into, а также исходные коды C++. Также она обладает отличными возможностями отладки с помощью debugWIRE или JTAG.

На нашем сайте вы можете прочитать статьи про программирование микроконтроллеров AVR с помощью программатора USBASP и Atmel Studio 7.0 и русификацию программы Atmel Studio 7.0.

Загрузка…

2 055 просмотров

Отладка программы является жизненно важным элементом при ее разработке. Программы для плат Arduino не являются в этом плане исключением. Процедура программирования плат Arduino достаточно проста, чего нельзя сказать о способах отладки программ, доступных для данной платформы. Одна из причин этого заключается в том, что платформа Arduino не располагает специализированными инструментами отладки программ, хотя в новой Arduino IDE pro такой инструмент все же появился.

В данной статье мы рассмотрим собственные (доступные в Arduino IDE) и внешние инструменты отладки программ для плат Arduino.

Также отладку программ для плат Arduino удобно производить в симуляторе UnoArduSim.

Собственные средства отладки в Arduino IDE

В Arduino IDE есть ряд собственных инструментов, которые можно использовать для отладки программ – это компилятор, монитор последовательного порта (Serial Monitor) и последовательный плоттер (построитель графиков в реальном времени по данным из последовательного порта). А в Arduino IDE Pro уже доступен свой собственный отладчик. Давайте рассмотрим эти инструменты более подробно.

Компилятор

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

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

Монитор последовательного порта

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

Вы можете выводить в окно монитора последовательного порта следующие данные, которые могут пригодиться для отладки программы:

• значения входных контактов (обычно это данные, считываемые с каких либо датчиков);
• значения переменных в программе. По изменению их значений вы можете, например, делать выводы о том, исполняются или нет условные операторы (‘if’) в вашей программе;
• значения выходных контактов (например, значения ШИМ перед подачей их непосредственно на контакт).

Средства отладки в Arduino IDE Pro

Arduino IDE Pro имеет встроенные средства отладки программ, которых нет в обычной Arduino IDE, что делает ее особенно полезной при разработке сложных программ.

К средствам отладки в Arduino IDE Pro относятся:

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

Другими дополнительными функциями Arduino IDE Pro являются отладка в реальном времени, автозаполнение, адаптивный интерфейс и более быстрое время компиляции.

Внешние инструменты отладки программ для плат Arduino

Если рассмотренные в предыдущем разделе статьи собственные средства отладки платформы Arduino вам не помогли найти ошибки в коде программы, то можно попробовать использовать внешние инструменты отладки программ. Далее мы рассмотрим наиболее популярные из этих инструментов.

Visual Micro

Visual Micro – это плагин для Microsoft Visual Studio, который позволяет разрабатывать кросс-платформенные приложения Arduino. Любой код, написанный на Visual Micro и соответствующий спецификациям Arduino, будет одобрен. Поскольку Visual Micro позволяет изменять общий код и библиотеки, он идеально подходит для случаев, когда написание и отладка кода программа производится несколькими участниками (командой разработчиков). Код с нескольких платформ может быть разработан и интегрирован с программным кодом в процессе компиляции. Visual Micro также обеспечивает отладку GDB и отладку фрагментов кода программы, работающих с последовательными портами связи, технологиями Bluetooth и WiFi.

DebugWire

DebugWire – это протокол, разработанный компаний Atmel и позволяющий производить отладку программ, написанных для микроконтроллеров серий ATTiny (ATTiny 13, 85 и др.) и ATmega (ATmega 32/48/88/168/328), без использования интерфейса JTAG, используя только контакт сброса (Reset pin). Компания Atmel не выкладывает документацию протокола debugWIRE в открытый доступ, однако ряд энтузиастов перепроектировали его большие разделы и смогли создать несколько базовых отладчиков на его основе. Протокол DebugWire обеспечивает полный доступ на чтение и запись ко всей памяти микроконтроллеров AVR, а также полный контроль над процессом выполнения программы. Он поддерживает следующие инструменты отладки программ:

• пошаговое выполнение программы (по одной строчке в коде программы);
• выполнение программы до позиции курсора;
• пошаговый выход;
• прерывание работы программы.

Atmel Studio

Atmel Studio IDE — это бесплатная программа, которая обладает весьма неплохими возможностями отладки программ. Atmel Studio позволяет разрабатывать, компилировать и загружать программу в соответствующий микроконтроллер. IDE Atmel Studio, как и Arduino IDE, использует один и тот же код, поэтому вам не нужно изучать новый язык программирования, чтобы использовать Atmel Studio.

Atmel Studio обладает высокой адаптивностью и поддерживает чертежи .into, а также исходные коды C++. Также она обладает отличными возможностями отладки с помощью debugWIRE или JTAG.

Источник

Arduino.ru

Пошаговая отладка

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

Извините если я повторяюсь, но не могу найти, как пройти по программе компелятором по шагам каждую строчку, чтобы посмотреть как наполняются переменные и функции?

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

Извините если я повторяюсь, но не могу найти, как пройти по программе компелятором по шагам каждую строчку, чтобы посмотреть как наполняются переменные и функции?

Arduino IDE — упрощенная любительская система начального уровня.

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

А как то руссифицировать эту Atmel Studio возможно?

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

А как то руссифицировать эту Atmel Studio возможно?

Описание с Торента по руссификации:

Чтобы в Atmel Studio6 появился русский язык необходимо установить Microsoft Visual Studio 2010 RUS. После установки MVS 2010 rus, в ATmel Studio6 появится выбор русского языка.

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

Подскажите, а как в АтмелСтудио загрузить скетч Ардуино, чтобы можно было пошаговую отладку запустить? Файл открыл, но отладка не доступна.

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

можно в коде ардуино понавставлять вывод нужного в Сериал.

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

В том то и дело что в сериал выводится что-то странное, надо отследить почему.

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

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

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

Нужна система отладки с контрольными точками. Плагин я установил, но не могу пока понять как все настроить чтобы работало.

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

Подскажите, а как в АтмелСтудио загрузить скетч Ардуино, чтобы можно было пошаговую отладку запустить? Файл открыл, но отладка не доступна.

Atmel Studio не работает со скетчами ардуино (только с чистым Си и Ассемблером). Но можно установить дополнительный плагин Visual Micro, который это позволяет (платный, есть триал).

Источник

Отладка скетчей Arduino

Библиотека Simple Dumping Monitor для Arduino-совместимых контроллеров на базе микроконтроллеров ATmega позволяет выводить дампы регистров, таймеров и памяти RAM, Flash и EEPROM, а также дамп таблицы векторов прерываний.

Библиотекой версии 0.21 поддерживаются микроконтроллеры:

• ATmega48P/88P/168P/328P — платы Arduino
• ATmega640/1280/1281/2560/2561 — платы Arduino MEGA
• ATmega16U4/32U4 — платы Arduino Leonardo
• ATmega164A/PA/324A/PA/644A/PA/1284/P — платы Sanguino/Daiduino

Начиная с версии 0.6 в библиотеку добавлены функции простого символьного отладчика.

В скомпилированном виде библиотека занимает около 11 Кб памяти (около 15 Кб — Arduino Mega). Требования к ОЗУ (RAM) не превышают 1 Кбайт (277 байт для примера dumpmon.pde, 377 байт для примера dumpmonDebug.pde).

Для использования библиотеки, нужно скачать файл с архивом. В архиве находится папка DumpMon, которую нужно распаковать в директорий libraries директория с библиотеками Arduino IDE. В результате должно получиться libraries/DumpMon .

В папке DumpMon/Examples находится скетч-пример dumpmonDebug.pde, который демонстрирует использование библиотеки для отладки скетча.

После успешной компиляции скетча и загрузки его в память Arduino, нужно открыть окно Serial Monitor, включить нужную скорость обмена (в примерах используется скорость 19200 бод). После этого можно отправлять Arduino команды для просмотра наблюдаемых переменных и управления отладкой:

• ? — вывод подсказки.
• W — вывод значений наблюдаемых переменных.
• S — перевод отладчика в режим пошагового выполнения.
• N — выполнить программу до следующей точки останова.
• G — выполнение программы в обычном режиме.
• A — повторить предыдущую команду.
• С — продолжить вывод дампа (для команды W — повторить вывод).

Команды и адреса можно вводить как в нижнем, так и в верхнем регистрах. Значения переменных и адресов выводятся в шестнадцатиричном формате.

Для использования отладчика библиотеки Simple Dumping Monitor, необходимо добавить в функцию setup() скетча вызов функции инициализации библиотеки, а также добавить переменные для наблюдения в список наблюдаемых переменных.

Функция dumpmonSetup() принимает два параметра:

• Скорость обмена последовательного порта USART в бодах (бит/сек.).
• Начальный режим отладчика (по умолчанию — пошаговый, что соответствует значению STEP_MODE ).

Поскольку по умолчанию используется пошаговый режим отладчика, то после сброса скетч будет выполнен до первого вызова функции breakpoint() . Для того, чтобы после сброса скетч работал как обычно, не останавливаясь на точках прерывания, функцию dumpmonSetup() следует вызвать с аргументом GO_MODE :

По умолчанию библиотека использует последовательный порт Serial ( USART0 ). Для использования другого последовательного порта микроконтроллеров ATmega1280/2560 ( Serial1 , Serial2 или Serial3 ) следует добавить в вызов функции dumpmonSetup() ссылку на данный порт:

Источник

Монитор порта, отладка

Как мы с вами знаем из урока “Что умеет микроконтроллер“, у многих микроконтроллеров есть интерфейс UART, позволяющий передавать и принимать различные данные. У интерфейса есть два вывода на плате – пины TX и RX. На большинстве Arduino-плат к этим пинам подключен USB-UART преобразователь (расположен на плате), при помощи которого плата может определяться компьютером при подключении USB кабеля и обмениваться с ним информацией. На компьютере создаётся виртуальный COM порт (последовательный порт), к которому можно подключиться при помощи программ-терминалов и принимать-отправлять текстовые данные. Таким же образом кстати работают некоторые принтеры и большинство станков с ЧПУ.

В самой Arduino IDE есть встроенная “консоль” – монитор порта, кнопка с иконкой лупы в правом верхнем углу программы. Нажав на эту кнопку мы откроем сам монитор порта, в котором будут настройки:

Если с отправкой, автопрокруткой, отметками времени и кнопкой очистить вывод всё и так понятно, то конец строки и скорость мы рассмотрим подробнее:

• Конец строки: тут есть несколько вариантов на выбор, чуть позже вы поймёте, на что они влияют. Лучше поставить нет конца строки, так как это позволит избежать непонятных ошибок на первых этапах знакомства с платформой.
  • Нет конца строки – никаких дополнительных символов в конце введённых символов после нажатия на кнопку отправка или клавишу Enter.
  • NL – символ переноса строки в конце отправленных данных.
  • CR – символ возврата каретки в конце отправленных данных.
  • NL+CR – и то и то.
• Скорость – тут на выбор нам даётся целый список скоростей, т.к. общение по Serial может осуществляться на разных скоростях, измеряемых в бод (baud), и если скорости приёма и отправки не совпадают – данные будут получены некорректно. По умолчанию скорость стоит 9600, её и оставим.

Объект Serial

Начнём знакомство с одним из самых полезных инструментов Arduino-разработчика – Serial, который идёт в комплекте со стандартными библиотеками. Serial позволяет как просто принимать и отправлять данные через последовательный порт, так и наследует из класса Stream кучу интересных возможностей и фишек, давайте сразу их все рассмотрим, а потом перейдём к конкретным примерам.

Запустить связь по Serial на скорости speed (измеряется в baud, бит в секунду). Скорость можно поставить любую, но есть несколько “стандартных” значений. Список скоростей для монитора порта Arduino IDE:

• 300
• 1200
• 2400
• 4800
• 9600 чаще всего используется, можно назвать стандартной
• 19200
• 38400
• 57600
• 115200 тоже часто встречается
• 230400
• 250000
• 500000
• 1000000
• 2000000 – максимальная скорость, не работает на некоторых китайских платах

Источник

Arduino Windows app
Не рекомендуется устанавливать Arduino Windows app из магазина приложений Windows, так как с ней бывают проблемы

Другие версии
Не устанавливайте старые версии IDE, если нет на то весомых причин, а также beta и hourly-билды

void setup() {
  pinMode(LED_BUILTIN, OUTPUT);
}
void loop() {
  digitalWrite(LED_BUILTIN, 0);
  delay(300);
  digitalWrite(LED_BUILTIN, 1);
  delay(300);
}

▶Проекты AlexGyver◀

ВНИМАТЕЛЬНО ЧИТАЙ ИНСТРУКЦИЮ
Если это твой первый опыт работы с Arduino — внимательно изучи каждый пункт инструкции выше, здесь всё написано!!!

#define SOME_SETTING 1  // 1 включено, 0 выключено

Предисловие

Как известно, среда Arduino (AVR) не содержит функции внутрисхемной отладки, что создаёт большие неудобства при поиске сложных ошибок и сопровождении проектов. Я хочу показать два способа, при помощи которых вы сможете отлаживать свои скетчи разного уровня сложности. Для первого способа вам понадобятся только программы, а для второго нужен недорогой (по сравнению с оригинальным отладчиком) адаптер, который вы можете либо собрать самостоятельно, либо купить готовый.
В общем, ничего нового для тех, кто пользуется отладчиками постоянно, но может быть полезным для пользователей Arduino (AVR).

Сборка при помощи Makefile

Прежде чем мы подойдём к описанию отладки в железе (во второй части) нам нужно немного потренироваться. Вероятно многие знают, что среда Arduino вызывает компилятор avr-gcc со всем окружением, автоматически настраивает параметры его вызова и запускает процесс сборки. Так вот, нам нужно повторить этот процесс явно. Делать это мы будем не вручную, хотя некоторые телодвижения всё-таки понадобятся. Нужно это для того, чтобы получить отладочный объектный файл в формате ELF. Среда Arduino подчищает за собой и у нас нет доступа ни к опциям компилятора, ни к результатам компиляции.

Это подводит нас к вопросу использования утилит для автоматической сборки avr-gcc проекта, а ещё точнее — скетча с библиотеками Arduino. Тут можно было бы погрустить, т.к. дело это не простое, но, как говорится, всё уже сделано до нас. Оказывается, на github уже есть всё необходимое именно для сборки скетчей с библиотеками Arduino. Проект называется Arduino-Makefile. Как не трудно догадаться из описания, этот проект содержит Makefile для автоматической сборки проектов на Arduino. Из перечисленных в описании особенностей мы обратим внимание только на некоторые.

Пакет Arduino-Makefile — это набор конфигурационных файлов, примеров и описаний. В нём нет утилит, которые всё это должны использовать. Нет также и среды разработки, т.е. сборка осуществляется через командную строку. Это означает, что вы можете прикрутить любую удобную для вас IDE, которая поддерживает сборку через Makefile. Я обычно использую Visual Studio.

Если внимательно посмотреть на содержимое, то можно заметить, что есть один глобальный универсальный Makefile (Arduino.mk), который включается в специфические местные файлы сборок. Вам нужно указать только частные (минимальные) настройки для конкретной цели сборки, а остальное будет выполнено в автоматическом режиме (настройка переменных, поиск зависимостей и прочее). Это очень удобно, как будет показано ниже.

Важно отметить, что поддерживаются файлы с различными расширениями (*.ino, *.pde, *.c и *.cpp). Дело в том, что одним из отладчиков у нас будет AVR Studio 4. При загрузке в неё отладочного файла исходники в дереве проектов будут расположены в разных папках: cpp-файлы в sources, а остальные в headers. Если мы оставим расширение для скетча (ino), то файл не попадёт в sources и на него не будет действовать подсветка синтаксиса. Смотреть на это невозможно. Поэтому возьмём на заметку, что расширение для скетчей при сборке для отладки в AVR Studio нужно поменять на стандартные (.c или .cpp).

Инструментарий

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

Способ 1. Создаём отладочный файл, загружаем его в Proteus, отлаживаем там же.

Достоинства:
— относительная простота отладки (с подключением монитора последовательного порта нужно будет только помучиться);
— доступ во внешний мир через последовательный порт;
— построение графиков (доступны виртуальные измерительные приборы);
— возможность моделировать схему в режиме реального времени;
— в отдельных окнах доступны регистры мк, области памяти, глобальные переменные и исходный код, конечно, в том числе его ассемблерный вариант.

Недостатки:
— платность Proteus;
— ограниченный набор периферии;
— сложные модели не могу учитывать всех особенностей оригинальных компонентов.

Способ 2. Создаём отладочный файл, загружаем его в AVR Studio 4, отлаживаем, используя специальный плагин Proteus VSM Viewer для AVR Studio 4.

По достоинствам и недостаткам почти то же, что и способе 1. Можно добавить, что AVR Studio показывает подробное дерево всех регистров моделируемого мк, вплоть до битов, что очень удобно. Из минусов стоит отметить, что отладка оптимизированного кода имеет свои особенности и не так просто понять как заставить отладчик останавливаться в нужных местах.

Способ 3. Создаём отладочный файл, загружаем его в AVR Studio 4, отлаживаем, используя программный эмулятор JTAG ICE mkII и специальный адаптер (HappyJTAG2).

Достоинства:
— это настоящая отладка в реальном «железе» с использованием JTAG ICE mkII отладчика (поддержка мк вплоть до ATmega2560);
— HappyJTAG 2.45 работает на Windows 7 x64, нужно только пропустить одно окошко, где просят всё-таки купить драйвера.

Недостатки:
— замечена нестабильная работа HappyJTAG2 с небольшими по объёму исходниками;
— нестабильная работа AVR Studio при выполнении отладочных действий;
— автор HappyJTAG2 давно забросил своё детище (видимо с приходом AVR Studio 5 и Atmel Studio);
— некоторые особенности подключения (COM4 или один из первых 4-х последовательных портов должен быть свободен или отсутствовать, т.к. AVR Studio перебирает COM1-COM4 в поиске отладчика). Именно свободен или отсутствовать, т.к. HappyJTAG2 работает, так скажем, «изнутри».

Как вы видите я показал три способа, но в настоящее время практически у меня заработали только два из них. Первый способ будет описан в этой статье. Второй способ, к сожалению, мне не удалось повторить. Нужно найти «совместимую» комбинацию Proteus и AVR Studio. На картинке использована последняя студия AVR Studio 4.19.730 и Proteus 7.7 SP2. Когда-то давно я использовал этот способ, но при наличии железного отладчика пользоваться им не имеет особого смысла. Третий способ я оставил для второй части. Там нужен будет адаптер и описание его подключения к платам Arduino, поддерживающим отладку по JTAG.

И что же для этой всей кухни нам понадобится? Для начала нужно забыть про убогое Arduino IDE, его можно использовать только для контрольных проверок при сборке скетчей. Далее, нам понадобятся:

— Arduino-Makefile — набор конфигурационных файлов для ручной сборки проектов на Arduino;
— какой-нибудь редактор с подсветкой синтаксиса C++ и умением выполнять внешние команды (Notepad++, VS20xx, Far, …);
— Proteus 7.x — известный симулятор смешанных (аналого-цифровых) схем;
— терминальная программа (PuTTY, ZOC Pro), которая будет аналогом монитора;
— программа, создающая нуль-модемные виртуальные последовательные порты (VSPD, …);
— Arduino IDE 1.6.x (нам нужны библиотеки и компилятор avr-gcc);
— WinAVR (нам нужны binutils из его комплекта, это набор unix команд для Windows);
— avr gcc 4.9.2 (компилятор посвежее, если не хотите использовать тот, что идёт в комплекте с Arduino IDE);
— AVR Studio 4.19.730 — последняя версия среды разработки от Atmel перед переходом на Visual Studio (понадобится только для второй части);
— HappyJTAG 2.45 (понадобится только для второй части).

Будем считать, что вы знаете как спросить у Google где достать всё это хозяйство. На всякий случай я приведу полезные ссылки в конце статьи. Некоторые комментарии по поводу инструментария.

Как известно, Proteus платный, но это не самое печальное. К сожалению, его библиотеки не на столько близки к реальному миру, как хотелось бы. К примеру, Ethernet shield W5100 вы промоделировать в нём не сможете (по крайней мере в версии 7.x). Поэтому, уважаемые последователи Arduino, идите истинным путём. Только отладка и только в железе спасут ваши души от неправильно поставленных вопросов. Proteus мы будем использовать как инструмент обучения, а в полевых условиях — только JTAG.

Отладка скетчей Arduino (AVR) в Proteus 7.x

Хватит общих слов, теперь конкретики. Есть много вариантов запуска процесса сборки, их все не распишешь, поэтому я остановлюсь на конкретно одном и постараюсь описать его понятно. Увидев общую схему, вы сможете применить её на свой набор средств разработки. Для удобства я разобью описание всего процесса по шагам, некоторые можно будет пропускать. Надеюсь, что даже самые неопытные пользователи Arduino поймут о чём речь.

Шаг 1. Скачиваем и устанавливаем среду разработки Arduino. Для определённости допустим, что она будет из серии 1.6.x. Здесь сразу сделаю несколько замечаний. Вообще, от Arduino нам нужны только библиотеки. Если не считать всего остального, то сама идея упрощённого вида программы очень даже хороша (если сравнить C# и C++ или, не дай боже, C++/CLI, то это небо и земля). Отсутствие же нормальных отладочных средств привело, прямо скажем, к безграмотному программированию. Вместо того, чтобы осознанно превращать задуманный алгоритм в программный код, пользователи Arduino вынуждены делать комбинации из магических заклинаний, выцеживать инфу через Serial.print() и только некоторые пытаются статически прочитать исходники библиотек. Тяжко на это всё смотреть.

Я отвлёкся, а вы, наверное, успели поставить среду по стандартным путям. Желательно, чтобы папка Arduino находилась в корне раздела (C:Arduino). Это связано с путями в makefile, которые не любят пробелы в «Program Files». Мы позже будем настраивать пути и для тех, у кого папка уже в «Program Files» придётся сделать одну сложную для пользователей Windows вещь — junction point на папку. Возможно, пробел можно экранировать, но я этого не пробовал.

Для определённости, допустим, что путь к среде такой: C:Program FilesArduino.

Шаг 2. Скачиваем и распаковываем Arduino-Makefile. Содержимое папки Arduino-Makefile-master распаковать в C:Arduino-Makefile. Хочу сразу отметить, что внутри есть файл README.md, который лучше посмотреть на github’е, где много чего описано. Также следует взять на заметку файл arduino-mk-vars.md, который содержит описание используемых в пользовательском (проектном) Makefile переменных.

Для работы утилиты make нужен комплект gnu bin utils, который входил в состав WinAVR в своё время. Я не знаю есть ли официальный сайт сборки этих самых утилит под Windows, но можно поступить следующим образом. Вам нужно будет скачать старый добрый WinAVR последней версии и вытащить из него папку utils, где находятся командные утилиты. Можно установить, скопировать папку и деинсталлировать WinAVR (потому что в его комплект входит старый компилятор avr-gcc, который нам не нужен).

Далее, к примеру, создать папку c:avr-gcc и скопировать utils в неё. После этого добавить в переменную PATH (через свойства Компьютера) путь C:avr-gccutilsbin:

set PATH=C:avr-gccutilsbin;%PATH%

Путь должен быть одним из первых в поиске. Не забывайте про это изменение, т.к. оно может повлиять на работу других программ, если вы используете другие подобные среды разработки.

Шаг 3. Сами знаете где берёте/покупаете Proteus [7.2 — 7.8]. Почему именно этой серии и такой интервал версий? Потому что я их пробовал и вроде бы на несложных проектах они вполне неплохи. Версии больше 7.8 не могли подгрузить объектный файл одного моего проекта в IAR, а ниже я не пробовал. Восьмёрка просто глючная пока, может быть потом кто-то напишет что-то и про неё. Здесь мы с вами возьмём конкретно Proteus 7.8 SP2.

Шаг 4. Используя статью, создаём junction point на папку с установленной средой Arduino, т.е. C:Arduino должна ссылаться на C:Program FilesArduino. Это нужно, чтобы не мудрить с поддержкой пробелов в makefile’ах. Т.о., не копируя папку с Arduino, мы получили её копию в нужном нам месте. Кто пользуется Far’ом может использовать комбинацию Alt+F6 на папке.

Изменяем настройки среды Arduino. Путь к папке со скетчами: C:Arduino-Makefileexamples. Если используете внешний редактор (Notepd++, …), то можете поставить галочку в настройках. При этом Arduino при активизации окна будет обновлять содержимое своего редактора автоматически. Выбираем плату Arduino Mega 2560 и процессор ATmega2560 (на самом деле не так важно что тут выбрать, главное определиться с используемым контроллером).

Пишем пример программы для тестирования сборки из среды Arduino, назовём её Example1 и сохраним в папке скетчей:

void setup()
{
DDRD |= ( 1 << DDD2 );
}

Компилируем и проверяем, что сборка проходит. У меня в Arduino 1.6.7 компоновщик объектных файлов (ld.exe) вылетел с ошибкой, я заменил его на другой (можно, к примеру, из этой сборки).

Шаг 5. Копируем файл C:Arduino-MakefileexamplesWebServerMakefile в папку с нашим скетчем: C:Arduino-MakefileexamplesExample1. Исправляем его содержимое следующим образом:

Вставляем вначале нашего исходника строчку, подключающую явно Arduino.h (это делать необязательно, если есть зависимости от библиотек, указываемые в переменной ARDUINO_LIBS):

#include "Arduino.h"

Не забываем сохранить исходник и Makefile. Далее, находясь в папке Example1, вводим команду make (при помощи консоли или в Far’е, или другим удобным способом), должна появиться большая портянка, похожая на ту, что выводится в Arduino IDE при включении вывода полной информации о процессе сборки. Это если всё было сделано правильно, если же что-то не получилось, то попытайтесь сначала самостоятельно понять что не так, а потом уж пишите комменты к статье.

Поскольку мы в Makefile закомментировали строку ARDUINO_QUIET = 1, то перед информацией о сборке идёт шапка со значениями переменных самого Makefile. Часть из них задана, а другие вычисляются по ходу выполнения. Это помогает находить ошибки при правке Makefile проекта.

Будем считать, что всё прошло успешно, тогда у вас должна появиться папочка build-mega, в котором наш долгожданный Example1.elf — этот тот самый файл, ради которого всё действо затевалось. Этим файлом мы «прошьём мозги» виртуальному мк в Proteus и заживём… с ещё одной степенью свободы.

Шаг 6. Вернёмся к Proteus. Создаём новый проект (dsn-файл)

в папке с исходником

. Достанем из недр библиотек компонент — микроконтроллер ATmega2560 и вставим его куда он поместится, уж здоровый больно. Заполните свойства компонента по картинке. Устанавливать COMPIM пока не обязательно, он понадобиться для работы с монитором.

Затем входим в режим отладки DebugStart/Restart Debugging. Получите картинку, похожую на такую.

Ну, а дальше, всё зависит от полёта вашей фантазии. В окошке исходников будет доступен не только Example1.ino, но и другие зависимые исходники. Можно раскрыть ассемблерный код, регистры процессора, память и что-то там вроде ещё. Читайте доку на Proteus.

Шаг 7. Нужно настроить монитор. Писать лень, надеюсь сделаете это уже самостоятельно. Смысл, вкратце, такой. Создаёте два виртуальных последовательных порта, соединённых нуль-модемом (лучше с номерами больше COM4). Один прописываете в компоненте COMPIM Proteus, а второй в терминальной программе (PuTTY). Не забудьте поправить скорость и кодировку вывода в терминальной программе, по идее она должна совпадать с кодировкой исходных файлов, если захотите делать вывод в монитор по-русски.

Шаг 8. Если хотите использовать avr gcc 4.9.2, то нужно положить содержимое архива в корень диска и исправить путь в переменной AVR_TOOLS_DIR. Только там у меня не заработал avr-size, кажется. Можно поменять его на тот, что идёт в комплекте WinAVR (или Arduino).

Кстати, чтобы размер выводился в нормальном виде нужно добавить опцию в вызов avr-size (файл Arduino.mk):

avr_size = $(SIZE) $(SIZEFLAGS) --format=avr $(1)


Полезные ссылки:

1. Arduino IDE 1.6.x.
2. Arduino-Makefile.
3. WinAVR.
4. avr gcc 4.9.2.
5. Hard links и пр. в Windows.
6. PuTTY.
7. Notepad++.

Проверка на корректность кода…

/*
  Скетч для вывода в Монитор порта теспературы в Цельсиях и Влажности
  с датчика DHT22 и отправки их по MQTT в брокер и MajorDoMo.
*/

#include <SPI.h>                 // Библиотека SPI шины
#include <Ethernet.h>            // Ethernet библиотека
#include <PubSubClient.h>        // Библиотека MQTT
#include <DHT.h>                 // Библиотека для датчиков DHT11/22

#define DHTPIN 2                 // Номер пина, к которому подсоединен датчик
#define DHTTYPE DHT22            // Задаём тип DHT датчика
DHT dht(DHTPIN, DHTTYPE);


// Задаём mac и ip адреса в Локальной сети
byte mac[]    = { 0xDE, 0xED, 0xBA, 0xFE, 0xFE, 0xED };
IPAddress ip{192, 168, 1, 74};      //ip Адрес Ethernet Shild'a Arduino
IPAddress server{192, 168, 1, 70};  //ip Адрес для MQTT Брокера

// Шапка Функции Callback (обратный вызов)
void callback(char* topic, byte* payload, unsigned int length);

EthernetClient ethClient;                                 //Инициализируем Ethernet клиент
PubSubClient client(server, 1883, callback, ethClient);   //Инициализируем MQTT клиент


// Функция Callback
void callback(char* topic, byte* payload, unsigned int length)
{
  // Выделяем необходимое кол-во памяти для копии payload
  byte* p = (byte*)malloc(length);
  // Копирование payload в новый буфер
  memcpy(p, payload, length);
  client.publish("home/data/status/sensor", p, length);
  // Освобождаем память
  free(p);
}


void setup()
{
  // 1 бод равно 0.8 бит/сек
  // 1 бит/сек равно 1.25 бод
  Serial.begin(9600);             // Задаём скорость порта в БОД'ах.
  Serial.println("DHT22 test!");  // Тестовое сообщ. при откр. Монитора порта

  dht.begin();

  Ethernet.begin(mac, ip);        // Инициализируем mac, ip


}


void loop() {

  int h = dht.readHumidity();     // Переменная типа int для Влажности
  int t = dht.readTemperature();  // Переменная типа int для Температуры

  // Преобразуем переменные для отправки в MQTT в Брокер
  static char char_temp[7];      // Переменная для перевода из int в char
  dtostrf(t, 3, 0, char_temp);    // Перевод из int в char

  static char char_hum[7];
  dtostrf(h, 3, 0, char_hum);

  if (client.connect("DHTClient"))  //Если DHTClient подкл., то выполняется код...
  {
    if (isnan(t) || isnan(h))     // Проверка удачно ли прошло считывание с DHT22
    {
      Serial.println("Failed to read from DHT22");  // Не удалось прочитать DHT22
    } else {
      // Отправка данных в Монитор порта при удачной проверке
      Serial.print("Humidity: ");
      Serial.print(h);
      Serial.print(" %t");
      Serial.print("Temperature: ");
      Serial.print(t);
      Serial.println(" *C");

      //Отправка данных по MQTT в Брокер
      client.publish("home/data/status/sensor/temp", char_temp);  //Температура
      client.publish("home/data/status/sensor/hum", char_hum);    //Влажность
      delay(5000);              // Отправка данных в Брокер раз в 5 секунд
    }

  } else {
    client.disconnect();      // иначе отключиться
  }
}

C:UsersLinuxDocumentsArduinoMQTT_DHT22MQTT_DHT22.ino:29:6: warning: unused parameter 'topic' [-Wunused-parameter]

 void callback(char* topic, byte* payload, unsigned int length)

      ^

Существует простой способ в два раза увеличить скорость загрузки скомпилированного кода в микроконтроллер при использовании Arduino IDE.

Заходим в в Arduino IDE, снимаем галочку с пункта Проверка кода после загрузки и жмем . Вот и все что нужно сделать. Не верите? Откроем большой скетч, который занимает около 30 килобайт во флеш-памяти микроконтроллера. С выбранным пунктом проверки, загрузка файла занимает примерно 24 секунды. Сняв отметку, мы выполним это же действие примерно за 13 секунд.

Что при этом происходит? По умолчанию, Arduino IDE проверяет, что все было записано правильно:

Загрузка:

Проверка:

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

На самом деле, даже с выключенной проверкой, все равно будут произведены две другие проверки ошибок. Одна на уровне загрузчика — каждый блок данных загрузчика STK500 имеет, так называемый циклический избыточный код (Cyclic redundancy check, CRC), который представляет из себя алгоритм нахождения контрольной суммы, предназначенный для проверки целостности данных. Другая проверка происходит на уровне соединения между USB и последовательным интерфейсом микроконтроллера (каждый блок данных, переданных через USB имеет свой CRC). Если какое-то сообщение будет повреждено, оно выявляется и исправляется на этих уровнях. Маловероятно, что что ваш скетч будет записан неправильно в Arduino, после того, как вы нажмете .

Почему это важно?

Многие скетчи занимают несколько тысяч байт и, выключив проверку, вы сэкономите лишь несколько секунд при их загрузке. Но сколько раз вы загружаете скетч, когда вы работаете над проектом? 10 раз? 50? И над сколькими проектами вы могли бы работать? Некоторые, наверное, загрузили уже десятки тысяч скетчей. Теперь умножьте на казалось бы незначительную экономию при загрузке и вы получите внушительное количество сэкономленного времени. В любом случае, будет точно не хуже, если вы меньше времени будете тратить на наблюдение за миганием светодиодов на TX и RX.

Случаи, при которых проверка не помешает

В некоторых случаях вы, возможно, все же захотите проверить свой ​​код. Если вы собираетесь поместить Arduino в спутник или в какой-либо другой ответственный проект, вы можете спать спокойнее, зная, что загруженный в него код является корректным. Если вы подкючаетесь к Arduino при помощи 15-метрового USB-кабеля или у вас провод длиной 2 км при передаче через интерфейс RS485, вы, возможно, захотите произвести проверку после загрузки своего скетча. Хотя также маловероятно, что ошибка проскочет через проверку контрольных сумм, так что решайте сами делать проверку или нет.

На каких платах этот трюк работает?

Это работает с любой платой Arduino, которая использует соединение последовательное USB-соединение (Uno, Mega, Pro Mini, LilyPad Simple, Fio и т.д.). Эти все платы используют один и тот же загрузчик avrdude, в котором по умолчанию устанавливается флаг проверки.

Любые платы, использующие загрузчик Catarina (Leonardo, Micro и т.д.) или загрузчик Halfkay (платы Teensy) имеют гораздо более быстрее загрузчики, и для них преимущество в скорости неочевидно.

Еще раз повторюсь, что вероятность пропуска ошибки в процессе минимальна, а поэтому, вполне можно довериться компилятору и снять этот флажок!

Источник: Sparkfun

Написал универсальный скетч для проверки работоспособности портов и EEPROM памяти. Ищутся добровольцы для проверки в железе и доработки тестовой программы. Мой код проверен на ATmega128A, ATmega8A при этом никаких правок в коде делать не нужно. Количество цифровых и аналоговых выводов определяется автоматически.

Что еще нужно сделать:

1. Проверка аппаратных прерываний, таймеров, прерываний по переполнению таймера.

2. Прошивка на асме для проверки RAM, Stack Pointer Register, Status Register, регистров R0-R25, X,Y,Z

Что уже было сделано: Мой код при запуске ничего не делает, он ждет команду по UART. В терминал нужно отправить одну английскую букву для запуска нужного теста. Когда какой то тест был запушен, чтобы его прервать нажмите кнопку ресет. Список комманд:

v — Выводит версию программы и краткое описание доступных тестов.

a — АЦП тест. Выводит значения всех аналоговых входов. Для этого вы подключаете переменный резистор поочередно к каждому аналоговому входу и смотрите как меняются значения.
i — Inputs test. В этом тесте включена подтяжка всех входов (INPUT_PULLUP). Тест выводит значения всех входов с низким уровнем на них. Вы берете провод подключенный на землю и через резистор 1КОм по очереди качаетесь каждого входа, в терминале должна появиться только одна надпись LOW с номером вывода. Этот тест позволяет найти замкнутые между собой пины или дорожки с обрывом (а также выводы со сгоревшими внутренними PULLUP резисторами)
o — Outputs test. Устанавливает все порты как выход с 1 на них. Вы берете тестер или светодиод с резистором и проверяете наличие высокого уровня на каждом выходе.
b — Blink. Тест наплатного светодиода.
0 — ZEROFILL встроенного EEPROM (тоесть заполнение нулями 0x00 во все ячейки). Тест закончится, когда будет выведено «Done» в консоль. После этого запустите комманду «e» для вывода содержимого EEPROM в консоль и проверьте нет ли бытых ячеек
1 — 0xFF заполнение встроенного EEPROM. Тест закончится, когда будет выведено «Done» в консоль. После этого запустите комманду «e» для вывода содержимого EEPROM в консоль и проверьте нет ли бытых ячеек
p — Тест ШИМ на наплатном светодиоде. Тест надо полностью переписать, текущая реализация мне не нравится.

e — Выводит все содержимое EEPROM в терминал.

Цифровые порты 0 и 1 не тестируются. Этот тест предполагает, что выводы 0 (RX) и передачи данных 1 (TX) данных в порядке, раз у вас получилось загрузить скетч.

Код состоит из двух файлов. Последняя версия всегда доступна по ссылке

Файл hwtest.ino

#define FIRST_PIN 2
#define PIN_LED  13

#define DELAY_ITERATION  200
#define DELAY_BW_TESTS  2000
#define DELAY_WARN  5000
#define ADC_NUMSAMPLES 8
int samples[ADC_NUMSAMPLES];

#include <EEPROM.h>

void setup() {
  Serial.begin(9600);
  pinMode(PIN_LED, OUTPUT);
}

void loop() {
  digitalWrite(PIN_LED, LOW);
  if (Serial.available() > 0) {

    switch (Serial.read()) {
      case 'v':
        Serial.println("Arduino hardware test v. 1.1b");
        Serial.println("a) ADC MANUAL test. Prints values from all analog pins");
        Serial.println("i) Inputs MANUAL test. Prints all inputs with LOW level on them");
        Serial.println("o) Outputs MANUAL test. Sets all ports to HIGH");
        Serial.println("b) Blink. Tests onboard led");
        Serial.println("0) Zerofill of built-in EEPROM");
        Serial.println("1) 0xFF fill of built-in EEPROM");
        Serial.println("p) Test PWM on on-board LED");
        Serial.println("");
        break;
      
      case 'a': //ADC test Tests all analog pins (A0-A7)
        while(true) {
          Serial.println("ADC test");
          readAnalogValue(A0);
          readAnalogValue(A1);
          readAnalogValue(A2);
          readAnalogValue(A3);
          readAnalogValue(A4);
          readAnalogValue(A5);
          
          #if(NUM_ANALOG_INPUTS == 8)
            readAnalogValue(A6);
            readAnalogValue(A7);  
          #endif
          digitalWrite(PIN_LED, LOW);
          delay(DELAY_BW_TESTS);          
        }
        break;

      case 'i': //Inputs test. Tests all inputs in digital mode
        while(true) {
          Serial.println("Inputs test. Pins in LOW state:");
          for(byte pin = FIRST_PIN; pin <= NUM_DIGITAL_PINS; pin++) {
            pinMode(pin, INPUT_PULLUP);
            if(!digitalRead(pin)) {          
        
              if(pin < 10) Serial.print(" PIN:  ");
              else Serial.print(" PIN: ");
              Serial.print(pin);
              Serial.println(" LOW"); //Should be no "LOW" messages if all pins is not connected to GND
            }
          }
          delay(DELAY_BW_TESTS);
          digitalWrite(PIN_LED, !digitalRead(PIN_LED)); //Toggle LED
        }
        break;

      case 'o': //Outputs test. Tests setting all ports to HIGH
          Serial.println("Outputs test. All set to HIGH");
          for(byte pin = FIRST_PIN; pin <= NUM_DIGITAL_PINS; pin++) {
            pinMode(pin, OUTPUT);
            digitalWrite(pin, HIGH);
          }
        break;
        
      case 'b': //Blink. Tests onboard led
        while(true) {
          Serial.println("Blink");
          digitalWrite(PIN_LED, HIGH);
          delay(1000);
          digitalWrite(PIN_LED, LOW);
          delay(1000);
        }
        break;
        
      case 'e':
        e2reader();
        break;
        
      case '0': //Zerofill of built-in EEPROM
        Serial.println("Zerofill of EEPROM in 5s");
        delay(DELAY_WARN);
        Serial.println("Started");
        for(int i=0; i<EEPROM.length(); i++) {
          EEPROM.write(i, 0);
        }        
        Serial.println("Done");
        break;

      case '1': //0xFF fill of built-in EEPROM
        Serial.println("0xFF Fill of EEPROM in 5s");
        delay(DELAY_WARN);
        Serial.println("Started");
        for(int i=0; i<EEPROM.length(); i++) {
          EEPROM.write(i, 255);
        }        
        Serial.println("Done");
        break;

      case 'p': //Test PWM on on-board LED
        while(true) {
          Serial.println("LED PWM control");
          // fade in from min to max in increments of 5 points:
          for (int fadeValue = 0 ; fadeValue <= 255; fadeValue += 5) {
            // sets the value (range from 0 to 255):
            analogWrite(PIN_LED, fadeValue);
            delay(40);
          }
        
          // fade out from max to min in increments of 5 points:
          for (int fadeValue = 255 ; fadeValue >= 0; fadeValue -= 5) {
            analogWrite(PIN_LED, fadeValue);
            delay(40);
          }
        }
      break;
    }
  }
}

void readAnalogValue(int adcPin) {    
  int i;
  for (i=0; i<ADC_NUMSAMPLES; i++) {
   samples[i] = analogRead(adcPin);
   delay(60);
  }
 
  // average all the samples out
  int average=0;
  for (i=0; i<ADC_NUMSAMPLES; i++) {
     average += samples[i];
  }
  average /= ADC_NUMSAMPLES;

  Serial.print("ADC PIN: ");
  Serial.print(adcPin);
  Serial.print(" value: ");
  Serial.println(average);
  digitalWrite(PIN_LED, !digitalRead(PIN_LED)); //Toggle LED
}

Файл EEPROM.ino

#include <EEPROM.h>
 
void e2reader(){
  char buffer[16];
  char valuePrint[4];
  byte value;
  unsigned int address;
  uint8_t trailingSpace = 2;
 
  Serial.print("Dumping "); Serial.print(E2END + 1);
  Serial.println(" bytes from EEPROM.");
  Serial.print("baseAddr ");
  for(int x = 0; x < 2; x++){
    Serial.print(" ");
    for(int y = 0; y < 25; y++)
      Serial.print("=");
  }
 
  // E2END is a macro defined as the last EEPROM address
  // (1023 for ATMEGA328P)
  for(address = 0; address <= E2END; address++){
    // read a byte from the current address of the EEPROM
    value = EEPROM.read(address);
 
    // add space between two sets of 8 bytes
    if(address % 8 == 0)
      Serial.print("  ");
 
    // newline and address for every 16 bytes
    if(address % 16 == 0){
      //print the buffer
      if(address > 0 && address % 16 == 0)
        printASCII(buffer);
 
      sprintf(buffer, "n 0x%05X: ", address);
      Serial.print(buffer);
 
      //clear the buffer for the next data block
      memset (buffer, 32, 16);
    }
 
    // save the value in temporary storage
    buffer[address%16] = value;
 
    // print the formatted value
    sprintf(valuePrint, " %02X", value);
    Serial.print(valuePrint);
  }
 
  if(address % 16 > 0){
    if(address % 16 < 9)
      trailingSpace += 2;
 
    trailingSpace += (16 - address % 16) * 3;
  }
 
  for(int i = trailingSpace; i > 0; i--)
    Serial.print(" ");
 
  //last line of data and a new line
  printASCII(buffer);
  Serial.println();
}
 
void printASCII(char * buffer){
  for(int i = 0; i < 16; i++){
    if(i == 8)
      Serial.print(" ");
 
    if(buffer[i] > 31 and buffer[i] < 127){
      Serial.print(buffer[i]);
    }else{
      Serial.print(".");
    }
  }
}

Подключаем шаговый двигатель 28BYJ к Arduino.

В этом уроке нам понадобится:

Для реализации проекта нам необходимо установить библиотеки:

Сборка:

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

Так же на драйвере есть 4 управляющих пина, который нужно подключить соответственно к 8 Pin ,9 Pin,10 Pin,11 Pin Ардуины.

Скетч:

Подключаем шаговый двигатель 28BYJ к Arduino.

В этом уроке нам понадобится:

Для реализации проекта нам необходимо установить библиотеки:

Сборка:

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

Так же на драйвере есть 4 управляющих пина, который нужно подключить соответственно к 8 Pin ,9 Pin,10 Pin,11 Pin Ардуины.

Скетч:

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

Шаг 1. Что такое шаговый двигатель?

Шаговый двигатель состоит из двух основных частей: ротора и статора.

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

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

Шаг 2: Список деталей

Необходимые детали для проекта Ардуино шагового двигателя:

• Шаговый двигатель (этот двигатель был взят от старого принтера)
• Arduino
• Изолированный медный провод
• Проволочные резаки / стрипперы
• Регулятор тока
• транзистор
• драйвер двигателя H-Bridge 1A
• моторный шилд

• паяльник
• припой
• инструменты
• безопасные очки

Шаг 3: Присоединяем провода

Большинство шаговых двигателей имеют четыре провода, поэтому вам нужно будет обрезать четыре медных провода (обратите внимание, что цвет не коррелирует с чем-либо конкретным (обычно есть правило, что черный — это земля, но не сейчас). Различные цвета были использованы только для облегчения понимания. Эти выводы будут использоваться для управления, какая катушка в настоящее время активна в двигателе. Для этого проекта Ардуино шаговый двигатель был взят от старого принтера, поэтому пайка проводов была самым простым вариантом для этого проекта. В любом случае, вы можете безопасно установить соединение (пайка, штекер, клипы).

Шаг 4: Эскиз/скетч Arduino

Arduino уже имеет встроенную библиотеку для шаговых двигателей. Просто перейдите в меню:

Файл → Примеры → Шаговые → stepper_oneRevolution
File → Examples → Stepper → stepper_oneRevolution

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

То, что на самом деле делает библиотека Stepper — чередует сигналы HIGH и LOW для каждой катушки, как показано в анимации выше.

Шаг 5: Что такое мост H-bridge?

H-Bridge — схема, состоящая из 4 переключателей, которые могут безопасно управлять двигателем постоянного тока или шаговым двигателем. Эти переключатели могут быть реле или (чаще всего) транзисторами. Транзистор представляет собой твердотельный переключатель, который можно закрыть, посылая небольшой ток (сигнал) на один из его контактов.

В отличие от одного транзистора, который позволяет вам контролировать скорость двигателя, H-мосты позволяют вам также контролировать направление вращения двигателя. Он делает это, открывая различные переключатели (транзисторы), чтобы ток тек в разных направлениях и, таким образом, изменяя полярность на двигателе.

H-Bridges может помочь вам предотвратить перегорания вашего Arduino моторами, которыми вы пользуетесь. Двигатели являются индукторами, а это означает, что они хранят электрическую энергию в магнитных полях. Когда ток больше не посылается двигателям, магнитная энергия возвращается в электрическую энергию и может повредить компоненты. H-Bridge помогает изолировать ваш Arduino лучше всего. Вы не должны подключать двигатель непосредственно к Arduino.

Хотя H-Bridges можно легко сделать самому многие предпочитают покупать H-Bridge (например, чип L293NE / SN754410) из-за удобства. Это чип, который мы будем использовать в этом уроке. Физические номера контактов и их назначение ниже:

• Пин 1 (1, 2EN) → Мотор 1 Включен/Выключен (HIGH/LOW)
• Пин 2 (1A) → Мотор 1 логический выход 1
• Пин 3 (1Y) → Мотор 1 терминал 1
• Пин 4 → Земля
• Пин 5 → Земля
• Пин 6 (2Y) → Мотор 1 терминал 2
• Пин 7 (2A) → Мотор 1 логический выход 2
• Пин 8 (VCC2) → Питание для двигателей
• Пин 9 → Мотор 2 Включен/Выключен (HIGH/LOW)
• Пин 10 → Мотор 2 логический выход 1
• Пин 11 → Мотор 2 терминал 1
• Пин 12 → Земля
• Пин 13 → Земля
• Пин 14 → Мотор 2 терминал 2
• Пин 15 → Мотор 2 логический выход 2
• Пин 16 (VCC1) → Питание для H Br >Шаг 6: Схема соединения

Схема соединения нашего проекта Ардуино шагового двигателя ниже.

Для шагового двигателя Ардуино 4 вывода на H-Bridge должны подключаться к 4 выводам двигателя. Затем 4 логических вывода подключаются к Arduino (8, 9, 10 и 11). Как показано на диаграмме выше, для питания двигателей можно подключить внешний источник питания. Чип может обрабатывать внешний источник питания от 4,5 до 36 В (мы выбрали батарею 9В).

Шаг 7: Загрузка кода и тестирование

Загрузите свой код в Ардуино. Если вы запустите свой код и все сработает так, как ожидалось, это потрясающе! Если провода вставлены в неправильные контакты, двигатель просто вибрирует, а не полностью вращается. Играйте со скоростью и направлением двигателя, как сочтете нужным.

На этом всё, теперь у вас должен быть рабочий шаговый двигатель Arduino. То, что вы сделаете дальше, зависит только от вас.

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

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

• применение интегрированных, уже имеющихся примеров;
• написание отдельных кодов самостоятельно.

Первый вариант является наиболее простым и самым распространенным. Ничего искать и скачивать из сети не нужно. Просто открываем среду Arduino IDE, заходим в меню, выбираем Файл, затем пункт Примеры, иподпункт Basics. Кликаем на один из самых простых примеров:

Запускаем его и работаем.

Обратите внимание на Панель управления софта (мы незаслуженно обходили ее стороной, исправляемся). Она имеет несколько клавиш.

Напомним их предназначение:

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

Ну и поговорим немного о сторонних скетчах, которые вы наверняка заметили в каждом нашем материале и схеме подключения на конкретных проектах. Если описывать наглядно, как выглядит методология их применения, то получится так. Сначала вы копируете скетч, вставляете его в соответствующее окно в утилите, кликаете на кнопку Компиляция, дожидаетесь ее окончания. Просто, не так ли?

Мы часто предлагали и будем это делать далее готовые скетчи для Arduino Uno. Так вот — многие из них подойдут и под другие контроллеры: Arduino Nano или Arduino Mega, об этом ищите указания в статьях. Это важно!

Фраза «Залить скетч» означает то, что его следует скопировать и вставить в форму для компиляции. Она часто встречается – потому будьте внимательны!

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