Создаем свою библиотеку arduino и загружаем в ide

Установка библиотек в Arduino IDE

Многие скетчи (программы) работают с библиотеками. Библиотека облегчает работу с определённым модулем или одним из типов модулей.

Например, если Вы хотите вывести текст на LCD дисплей без подключения библиотеки, то Вам нужно передать ему несколько байт команд и данных, что займет несколько строк кода, а главное, что Вам нужно знать тип микроконтроллера под управлением которого работает LCD дисплей, назначение команд которыми он управляется, знать архитектуру его памяти, адреса и назначение регистров, для чего потребуется найти и перечитать его datasheet. В то время как при написании кода с использованием библиотеки (например LiquidCrystal_I2C.h) Вы сможете вывести текст на дисплей вызвав всего одну функцию библиотеки: lcd.print(“my text”);

Перед тем как начать пользоваться методами и функциями библиотеки, её нужно скачать (загрузить на Ваш компьютер), установить (разместить в нужной папке) и подключить (вставить текст “#include ” в скетч).

Скачивание библиотеки:

Если в наших уроках, описаниях или примерах используется библиотека, то мы указываем ссылку на скачивание этой библиотеки. Все наши библиотеки находятся в zip архиве, но не спешите доставать файлы из архива, это может не понадобиться, т.к. Arduino IDE сама может распаковывать архивы и размещать библиотеки в нужных папках (см. дальше).

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

Установка библиотеки:

После того как Вы скачали (загрузили) библиотеку на свой компьютер, её нужно установить. Установить библиотеку можно вручную или сделать это средствами Arduino IDE:

Установка библиотеки средствами Arduino IDE:

Войдите в меню: Скетч > Подключить библиотеку > Добавить .ZIP библиотеку….

В появившемся окне нажмите на иконку «Этот компьютер» и выберите папку «Загрузки». Если при скачивании ZIP архива с сайта, Вы указывали путь для сохранения файла, то вместо папки «Загрузки» укажите путь к файлу.

Выберите ZIP файл библиотеки, который Вы скачали. Название файла может не соответствовать названию библиотеки. После чего нажмите на кнопку «Открыть» (Open).

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

Установка библиотеки вручную:

Распакуйте скаченный Вами ZIP архив и поместите папку (имя папки обычно совпадает с названием библиотеки) из данного архива в папку: Этот компьютер > Документы > Arduino > libraries.

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

Примечание: папка libraries есть не только по указанному выше пути, но и в папке программы Arduino IDE (где находится файл arduino.exe). Скопировав библиотеку в эту папку, она тоже установится, но Мы не рекомендуем это делать. Дело в том, что программа Arduino IDE постоянно развивается и количество её версий постоянно растёт.

Если Вы захотите установить новую версию Arduino IDE, то библиотеки находящиеся в папке Этот компьютер > Документы > Arduino > libraries, будут доступны и в старой, и в новой (установленной) версии Arduino IDE, а библиотеки находящиеся в папке libraries программы Arduino IDE старой версии (которая была установлена ранее) будут доступны только в ней (пока Вы их не скопируете в новую).

Подключение библиотеки:

Для того чтобы подключить библиотеку, нужно написать всего одну строку в начале скетча: “#include “, например:

#include // Подключение библиотеки iarduino_4LED для работы с 4 сегментными LED индикаторами.

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

#include // Подключение библиотеки Wire для работы с шиной I2C
#include // Подключение библиотеки LiquidCrystal_I2C для работы с LCD дисплеем по шине I2C // Библиотека LiquidCrystal_I2C использует методы и функции библиотеки Wire

Для работы с большинством библиотек, нужно создать объект (экземпляр класса библиотеки), через который будут доступны их функции и методы, например:

LiquidCrystal_I2C lcd(0x27,20,4); // lcd это объект библиотеки LiquidCrystal_I2C // через объект обращаются к функциям и методам библиотеки

Вместо lcd можно написать любое слово или сочетание букв и цифр, это название объекта через который можно обращаться к методам и функциям библиотеки. Если Вместо lcd Вы написали myLCD, то и ко всем методам и функциям библиотеки LiquidCrystal_I2C, нужно обращаться через указанное Вами имя объекта, например: myLCD.print(“my text”);

Примеры из библиотек:

Большинство библиотек содержат примеры. Это небольшие скетчи (программы) которые раскрывают функционал библиотеки. Наиболее удобный способ просмотра примеров, с помощью средств Arduino IDE.

Выберите пункт меню: Файл > Примеры, откроется список с названиями библиотек у которых есть примеры.

Наведите курсор на название библиотеки и Вы увидите список примеров содержащихся в ней, клик на примере приведёт к появлению нового окна Arduino IDE со скетчем примера.

Альтернативный способ просмотра примеров заключается в запуске файлов скетчей из папки:
путь > libraries > название библиотеки > examples > название примера.

Поиск библиотек:

Библиотеки можно искать самостоятельно, а можно воспользоваться функционалом Arduino IDE.

Выберите пункт меню: Скетч > Подключить библиотеку > Управлять библиотеками….

Откроется «Менеджер библиотек», в котором можно найти интересующую Вас библиотеку введя её название в строку поиска, дополнительно можно установить пункты «Тип» и «Тема».

Нажатие на описании библиотеки приведёт к появлению вкладки «Версия» и кнопки «Установка». После нажатия на кнопку «Установка» можно приступать к подключению библиотеки в скетч “#include “.

Источник: https://lesson.iarduino.ru/page/Installing_libraries

Установка и подключение библиотеки Ардуино

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

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

 В этой статье вы найдете короткую инструкцию по подключению и использованию библиотек.

Библиотеки в Arduino IDE

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

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

Наиболее популярные библиотеки можно найти на нашем сайте.

С точки зрения файловой системы библиотека представляет собой каталог, содержащий определенные папки.

Во время компиляции и сборки проекта Arduino IDE автоматически включает в код те классы, структуры данных и методы из библиотек, которые включены и используются в скетче.

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

Как узнать список подключенных библиотек к Arduino IDE

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

Другим способом является использование меню Скетч и подменю — Подключить библиотеку. Там вы тоже сможете увидеть список библиотек:

Список библиотек ардуино

Подключение оператором #include заголовочного h файла

Чтобы начать пользоваться библиотекой, нужно в начале программы включить заголовочный h файл директивой include. Например, подключение библиотеки LiquidCrystal.h будет выглядеть так: #include<\p>

Вы можете посмотреть полный пример, воспользовавшись самой библиотекой.

Обязательные файлы в библиотеке

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

Во втором файле содержатся коды методов. Помимо двух основных файлов может содержаться текстовый документы keywords.txt и папка examples  с кодами примеров использования библиотеки.

Файлы h и cpp не обязательно лежат в корне

Редактирование файлов невозможно в Arduino IDE, все изменения можно проводить в любом текстовом редакторе, либо среде разработки C++. Это связано с тем, что в Arduino IDE мы не работаем с файлами cpp, редактор кода не предназначен для «чистого» C, он работает только с языком Arduino.

Где найти нужную библиотеку

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

Папка, в которой сохранены все коды, создается на компьютере после установки Arduino IDE.

Для операционной системы Linux папка имеет название «Scetchbook» и располагается в /home/, на Windows папку «Arduino» можно найти в разделе «Мои документы».

Все библиотеки, которые установлены дополнительно, расположены в папке «Libraries». Для ранних версий Ардуино папку нужно создать самостоятельно, а начиная с версии 1.0.2, она добавляется при установке Arduino IDE автоматически.

Как установить библиотеку. Пошаговая инструкция

Как только библиотека будет загружена на ПК, нужно начать ее установку. Установить библиотеку можно двумя способами – при помощи средств Arduino IDE и вручную.

Подключение при помощи Arduino IDE

Библиотека скачивается в виде zip-архива. Для ее включения этим способом архив не нужно распаковывать. Чтобы установить ее, нужно зайти в меню Скетч – Подключить библиотеку – Добавить .Zip библиотеку.

Когда откроется окно, нужно выбрать папку «загрузки» в разделе «Этот компьютер». Если же после загрузки библиотеки она была сохранена в другое место, нужно указать его.

Затем нужно выбрать скачанный файл и нажать «открыть».

Библиотека будет установлена, и ей можно пользоваться. Для того, чтобы начать пользоваться примерами Файл – примеры, нужно перезагрузить среду разработки Ардуино.

Установка библиотеки вручную из zip-файла

Перед началом установки нужно выйти из Arduino IDE. Скачанный zip-файл с библиотекой нужно распаковать. В результате мы получим папку, в которой будут располагаться файлы библиотеки с расширением .cpp и .h и каталоги. Полученную папку нужно будет поместить в libraries.

В ОС Windows папку libraries можно найти по маршруту Мои документы – ардуино – libraries. В  Linux это будет папка libraries со скетчами.

В конце нужно перезапустить Arduino IDE, загруженная библиотека будет доступна для включения через Скетч – Подключить библиотеку.

Ошибки при подключении библиотеки Arduino

Ниже перечислен перечень возможных ошибок при установке библиотеки и способы борьбы с ними:

  • ‘xxxx’ does not name a type – подобная ошибка появляется, если библиотеку еще не установили, папка или библиотека названа неверно, указан неправильный адрес расположения папки или не перезапущена среда разработки Arduino IDE.
  • Неправильное расположение папки – если высветилась эта ошибка, нужно проверить, находится ли библиотека в папке, доступной для поиска средой.
  • Неправильное наименование библиотеки – ошибка появляется, если имя после #include не соответствует названию библиотеки.
  • Неполная библиотека – может появиться, если были скачаны не все нужные файлы и папки.
  • Зависимости библиотеки – так как этот тип библиотек работает только с дополнительными, нужно изначально подключить именно их.
Читайте также:  Обзор и подключение dht11 (dht22) датчика влажности и температуры - arduino+

Источник: https://ArduinoMaster.ru/biblioteki-arduino/podklyuchenie-biblioteki-arduino/

Установка и подключение библиотек Arduino

Стандартные библиотеки Arduino хранятся в папке:

«C:Program Files (x86)Arduinolibraries»

Дополнительные библиотеки устанавливаются в папку:

«C:Users*Имя Пользователя*DocumentsArduinolibraries»

В вашем случае эти пути могут быть другими из-за другой буквы основного жесткого диска и другого имени пользователя. Если у вас установлена 32х битная операционная система то папка «Program Files (x86)» будет называться «Program Files».

Установка библиотек Arduino

Установить библиотеки в Arduino IDE очень просто. Можно сделать это двумя способами. Через интерфейс программы или копированием скачанной библиотеки в папку «libraries». Рассмотрим подробнее оба варианта:

Установка библиотек через Arduino IDE

Первый вариант — это установка библиотек Ардуино из официального репозитория. Для этого необходимо запустить Arduino IDE, в верхнем меню выбрать «Скетч -> Подключить библиотеку -> Управлять библиотеками».

Установка библиотек ардуино

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

Библиотеки Arduino установить

Второй вариант — это установка библиотеки из скачанной .zip папки. Через интерфейс Arduino IDE это можно сделать всего за пару кликов. В верхнем меню программ выбираем «Скетч -> Подключить библиотеку -> Добавить .ZIP библиотеку». Откроется окно файлового менеджера, где необходимо выбрать папку или .zip архив с вашей библиотекой.

Еще один способ установки библиотек Ардуино

Вы можете просто перенести папки библиотек по пути:

«C:Program Files (x86)Arduinolibraries»

После того как вы добавили свои библиотеки необходимо перезапустить Arduino IDE. Теперь вы можете использовать сторонние библиотеки в своих проектах.

Подключение библиотеки Arduino

Мало установить библиотеку. Для использования ее необходимо подключить в скетч. Сделать это очень просто. Можно в начале скетча вручную написать подобную строчку:

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

Источник: https://all-arduino.ru/rabota-s-bibliotekami-arduino/

Программирование Arduino – создание своей библиотеки

12. Cоздание своей библиотеки.

На примере библиотеки для работы с PS/2-устройствами можно оценить как здорово работать через библиотеку 🙂

Раз подключил и готово 🙂 Разумеется, нужно ещё разобраться что к чему, но главное – библиотека – это очень удобно 🙂 Поэтому, давайте научимся создавать собственную библиотеку для ардуино 🙂

Как мы помним, ардуина программируется на C++, поэтому, как Вы уже догадались, библиотека – это всего-навсего дополнительный класс, который инкапсулирует в себе функции для работы с устройством 🙂

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

cpp, в котором все эти функции реализуются 🙂 Итак, создаём в библиотечной директории Arduino IDE (hardwarelibraries) папку RoboCraft – так по-скромному будет называться наша библиотека 🙂 А внутри нашей новой директории создаём наши файлы

robocraft.h и robocraft.cpp

Ну что – можно сказать половина дела сделана 🙂 Библиотеки компилируется без дополнительных преобразований, поэтому их нужно писать на «чистом C++» и поэтому если внутри нашей библиотеки мы захотим использовать какие-нибудь функции или объекты из стандартной библиотеки Arduino, то нам нужно подключать соответствующий заголовочный файл («Arduino.h» (в старых версиях IDE: «WConstants.h», «WProgram.h»)) На всякий случай, напишем: #if defined(ARDUINO) && ARDUINO >= 100 #include “Arduino.h” #else #include “WProgram.h” #endif код оформляется в виде класса и если по смыслу выполняемых задач экземпляр этого класса может быть только один, то заодно происходит объявление этого экземпляра в .h файле. Пора писать код 🙂 Для начала, напишем что-нибудь простое, вроде обычного в таких случаях “Hello world”-а 🙂

— robocraft.h —

#ifndef robocraft_h #define robocraft_h #if defined(ARDUINO) && ARDUINO >= 100 #include “Arduino.h” #else #include “WProgram.h” #endif class RoboCraft { public: RoboCraft(); void hello(); }; #endif // #ifndef robocraft_h — robocraft.h end — , а теперь реализуем эти функции:

— robocraft.cpp —

#include “robocraft.h” // // конструктор – вызывается всегда при создании экземпляра класса RoboCraft // RoboCraft::RoboCraft() { Serial.begin(9600); } // // просто говорим “Hello” 🙂 // void RoboCraft::hello() { Serial.println(“Hello :)”); } — robocraft.cpp end — Остаётся перезапустить Arduino IDE и с удовольствием отметить появление нового класса (меню Sketch – Import Library ) 🙂
При выборе нашего (да и любого другого) класса – всего лишь появляется строчка#include допишем необходимые setup и loop:#include RoboCraft robot; // создаём экземпляр нашего класса void setup() { } void loop() { robot.hello(); // говорим “Hello” 🙂 }
Пробуем скомпилировать – «Done compiling» — с чем нас и поздравляю – наш класс работает! 🙂

Однако, заглянув в папку к любому другому классу в глаза бросаются файл keywords.txt и директория examples

Попробуем разобраться. Файл keywords.txt содержит объявления ключевых слов вашей библиотеки, имена типов, методов, функций, констант – это нужно, чтобы редактор “раскрашивал” их соответствующими цветами.

Синтаксис у файла простой — вот пример (разделитель — TAB):####################################### # Syntax Coloring Map For RoboCraft ####################################### ####################################### # Datatypes (KEYWORD1) ####################################### RoboCraft KEYWORD1 ####################################### # Methods and Functions (KEYWORD2) ####################################### hello KEYWORD2 ####################################### # Constants (LITERAL1) ####################################### Сохраним этот keywords.txt в каталог с нашей библиотекой и перезапустим Arduino IDE— сравните с предыдущим скриншотом – название нашего класса и функция hello() теперь подсвечиваются! 🙂 Теперь остаётся добавить к нашей библиотеке нужных и полезных примеров использования.

Для этого создаём директорию examples, а в ней поддиректории с примерами в формате .pde.

Например, скопируем туда наш скетч в директорию hello_robocraft и переименуем его аналогично в hello_robocraft.pde В очередной раз перезапускаем Arduino IDE и видим, доступность нашего примера :)Замечательно! Заготовка для нашей робототехнической библиотеки создана! 🙂

скачать библиотеку

Ссылки

Как сделать библиотеку для Arduino?

По теме

Как адаптировать библиотеки для Arduino 1.0

Источник: http://robocraft.ru/blog/arduino/102.html

Arduino: как создать свою библиотеку кода?

На основе примера генератора кода Морзе здесь показано, как сконвертировать его функции в библиотеку (перевод официальной документации [1]). Это позволит другим людям проще использовать код, и проще обновить свой проект, когда Вы улучшите библиотеку. Начнем с простого примера скетча, который генерирует морзянку, мигая светодиодом (после его запуска он постоянно выдает сигнал SOS):

int pin = 13;
void setup() { pinMode(pin, OUTPUT); }
void loop() { dot(); dot(); dot(); dash(); dash(); dash(); dot(); dot(); dot(); delay(3000); }
void dot() { digitalWrite(pin, HIGH); delay(250); digitalWrite(pin, LOW); delay(250); }
void dash() { digitalWrite(pin, HIGH); delay(1000); digitalWrite(pin, LOW); delay(250); }

В этом скетче есть несколько разных частей, которые нам нужно перевести в библиотеку. Первое, конечно же, это функции dot() и dash(), которые выполняют основную работу по миганию светодиодом .

Второе это переменная ledPin, которая используется функциями – эта переменная определяет, какой вывод порта использовать. И наконец, здесь есть вызов pinMode(), который настраивает вывод порта как выход.

Итак, давайте превратим код скетча в библиотеку.

Для библиотеки нам нужно как минимум 2 файла: файл заголовка (header file, файл с расширением .h) и файл исходного кода (с расширением .cpp).

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

Назовем нашу библиотеку “Morse”, так что заголовочный файл получит имя Morse.h.

[Заголовочный файл библиотеки]

Ядро файла заголовка состоит из нескольких строк, в каждой из которых описана одна функция, и все это объединено в класс вместе со всеми переменными, которые Вам нужны:

class Morse { public: Morse(int pin); void dot(); void dash(); private: int _pin; };

Класс это просто набор функций и переменных, содержащихся в одном месте. Функции и переменные имеют атрибут public, который означает, что эти функции доступны для всех, кто использует библиотеку, или private, который означает, что доступ возможен только из самого класса.

В каждом классе есть специальная функция, называемая конструктором, которая используется для создания экземпляра (instance) класса.

Конструктор всегда имеет то же самое имя, что и имя класса, и у не указан возвращаемый тип (потому что заранее известно, что он возвратит тип класса).

Примечание: определение класса в заголовке можно рассматривать как пользовательский ТИП (по аналогии с typedef struct), а экземпляр класса можно рассматривать как ПЕРЕМЕННУЮ, которая имеет этот тип.

Конструктор предназначен для инициализации этой переменной. Может быть также еще и деструктор, который предназначен для уничтожения переменной класса.

Наличие и конструктора, и деструктора необязательно: это зависит от реализации класса.

Кроме определения класса, в заголовочный файл нужно добавить подключение заголовка Arduino.h директивой #include. Это дает доступ к стандартным типам и константам языка Arduino. Заголовочный файл Arduino.h автоматически добавляется при компиляции скетча (см. [3]), но для библиотек это нужно сделать самому. Подключение заголовка Arduino.h будет выглядеть следующим образом:

В завершение нужно обернуть заголовочный файл в стандартную конструкцию #ifndef / #define / #endif (это защита от повторного включения заголовка []). Также в начало заголовка добавляют комментарии, описывающие содержимое библиотеки. В результате получится вот такой заголовок:

/* Morse.h – библиотека для генерации кода Morse. Автор David A. Mellis, 2 ноября 2007. Выпущено для публичного использования. */ #ifndef Morse_h #define Morse_h #include “Arduino.h” class Morse { public: Morse(int pin); void dot(); void dash(); private: int _pin; }; #endif

[Файл исходного кода библиотеки]

Займемся конструктором. В нем расположен код, который вызывается при создании экземпляра класса.

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

Таким образом, конструктор у нас будет конфигурировать ножку порта, и сохранит номер используемого порта в частную переменную _pin (эта переменная будет использоваться функциями класса):

Morse::Morse(int pin) { //Конфигурируем порт как выход: pinMode(pin, OUTPUT); //Сохраним номер порта во внутреннюю переменную класса: _pin = pin; }

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

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

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

Теперь напишем код для функций библиотеки.

Код будет выглядеть точно таким же, как он был в скетче, за исключением того, что к имени функции будет добавлен префикс Morse::, и будет использоваться частная переменная _pin вместо глобальной переменной pin. Нужно также добавить подключение заголовочных файлов и текст комментария в начало файла. В результате получится файл исходного кода (модуль) библиотеки:

/* Morse.h – библиотека для генерации кода Morse. Автор David A. Mellis, 2 ноября 2007. Выпущено для публичного использования. */ #include “Arduino.h” #include “Morse.h” Morse::Morse(int pin) { pinMode(pin, OUTPUT); _pin = pin; } void Morse::dot() { digitalWrite(_pin, HIGH); delay(250); digitalWrite(_pin, LOW); delay(250); } void Morse::dash() { digitalWrite(_pin, HIGH); delay(1000); digitalWrite(_pin, LOW); delay(250); }

Читайте также:  Программист микроконтроллеров stm32f/инженер встраиваемых систем

[Как использовать библиотеку]

Файлы библиотеки готовы. Теперь надо разобраться, как использовать библиотеку в среде разработки Arduino.

Сначала создайте папку Morse как поддиректорию в папке libraries (папка libraries находится в каталоге установки системы Arduino, полный путь до папки Morse будет наподобие C:Program FilesArduinolibrariesMorse). Скопируйте файлы Morse.h и Morse.cpp в директорию Morse.

После этого запустите среду разработки Arduino IDE. Если Вы зайдете в меню Sketch -> Import Library (Скетч -> Импортировать библиотеку), то среди списка библиотек Вы должны увидеть Morse. Библиотека будет компилироваться вместе с теми скетчами, которые её используют.

Если у Вас имеются проблемы при создании или компиляции библиотеки, то проверьте, что файлы действительно имеют расширения .cpp и .h – например, без дополнительного расширения .pde или .

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

Теперь давайте посмотрим, как можно создать скетч, который будет делать то же самое, что и раньше, но с использованием библиотеки:

#include < Morse.h > Morse morse(13); void setup() { } void loop() { morse.dot(); morse.dot(); morse.dot(); morse.dash(); morse.dash(); morse.dash(); morse.dot(); morse.dot(); morse.dot(); delay(3000); }

Очевидно, что есть несколько различий от старого скетча (основанные на том, что некоторая часть кода перемесилась в библиотеку). Кроме того, код значительно сократился, и стал читабельнее. Давайте рассмотрим эти отличия.

Директива #include. Первое отличие – добавлен оператор #include в самом начале скетча.

Это делает библиотеку Morse доступной для использования внутри скетча, и её код (при компиляции) будет добавлен в общий код, который будет впоследствии прошит в память микроконтроллера платы Arduino.

Это означает, что если больше в скетче не нужна библиотека, то Вы должны удалить подключение её заголовочный файла (закомментировать или удалить строку с соответствующей директивой #include).

Обратите внимание, что имя подключаемого файла теперь указано в угловых скобках, а не в двойных кавычках. Это обычная практика программирования на языках C/C++: имена стандартных библиотечных файлов в директиве #include указываются с использованием угловых скобок, а подключение заголовочных файлов пользователя указывается с помощью двойных кавычек.

Вызов конструктора класса. Второе отличие – как создается переменная класса Morse (в нашем примере мы создаем переменную класса morse):

Когда выполняется эта строка кода (это происходит до вызова функции setup()), то будет вызвана функция конструктора класса Morse, и ей будет передан аргумент (в нашем случае номер цифрового порта 13).

Обратите внимание, что функция setup() теперь пуста; это потому, что вызов pinMode() происходит внутри библиотеки (когда конструктор создает экземпляр переменной класса).

Вызов функций класса. Последнее отличие – функции dot() и dash() вызываются с префиксом из имени экземпляра класса и точки (morse.).

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

Путем вызова функции с отдельным экземпляром класса, мы указываем, какие экземпляры переменных используются для вызова функции. К примеру, если у нас есть два экземпляра класса:

Morse morse1(13); Morse morse2(12);

то внутри вызова morse2.dot(), значение переменной _pin будет 12.

[Подсветка синтаксиса библиотеки]

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

К сожалению, программное обеспечение среды разработки Arduino не может автоматически распознать определения в Вашей библиотеке (что было бы приятной возможностью), так что Вам нужно ей немного в этом помочь. Чтобы настроить подсветку синтаксиса для Вашей библиотеки, создайте файл keywords.

txt в каталоге Morse. Его содержимое должно выглядеть так:

Morse KEYWORD1 dash KEYWORD2 dot KEYWORD2

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

Имя класса должно быть обозначено как KEYWORD1, и это дает оранжевую подкраску; функции (методы) класса должны обозначены как KEYWORD2, и имена функций будут коричневыми. После создания файла keywords.

txt в каталоге Morse нужно перезапустить среду разработки Arduino, чтобы она распознала новые ключевые слова.

[Пример кода использования библиотеки]

Вместе с библиотекой полезно предоставить пример скетча с демонстрацией использования библиотеки. Для этого в директории Morse создайте подкаталог examples. Затем скопируйте или переместите папку, содержащую код скетча (пусть эта папка называется SOS), в папку examples.

Где находится копируемый скетч можно узнать из меню Sketch -> Show Sketch Folder (Скетч -> Показать папку скетчей). Если после этого Вы еще раз перезапустите среду разработки Arduino, то в меню File -> Sketchbook -> Examples (Файл -> Примеры) увидите Morse, и внутри неё пример SOS.

Также для кода примера можно создать дополнительные комментарии, чтобы лучше разъяснить, как использовать Вашу библиотеку.

Если Вы хотите проверить содержимое готовой библиотеки, то можете загрузить её: Morse.zip [3].

Вы также можете просмотреть реализации других готовых библиотек, которые можете найти в папке libraries каталога установки Arduino.

Дополнительную информацию по Arduino-стилю оформления библиотек можете получить из [2]. Если у Вас есть вопросы, то можете задать их на форуме разработчиков Arduino [4].

[Ссылки]

1. Writing a Library for Arduino site:arduino.cc.
2. Arduino Style Guide for Writing Libraries site:arduino.cc.
3. Morse.zip – архив копии каталога библиотеки, содержимое архива следует поместить в папку libraries каталога установки Arduino IDE.
4. Arduino Forum > Software > Development site:forum.arduino.cc.

Источник: http://microsin.net/programming/avr/writing-arduino-library.html

Как добавить библиотеки в arduino IDE через менеджер библиотек в ручном (zip) и автоматическом режиме

Сегодня мы рассмотрим подключение OLED I2C дисплея с размером экрана 0,96″ и разрешением 128*64 точек к плате Arduino UNO.

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

Печатаем и собираем экструдер – принтмод для 3д принтера по типу мк8 го экструдера .

В посте собраны практически все платы ардуино с распиновкой в хорошем качестве !

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

Ардуино – это открытая программируемая аппаратная платформа для работы с различными физическими объектами и представляет собой простую плату с микроконтроллером, а также специальную среду разработки для написания программного обеспечения микроконтроллера.

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

Проекты Ардуино могут быть как самостоятельными, так и взаимодействовать с программным обеспечением, работающем на персональном компьютере (например, приложениями Flash, Processing, MaxMSP).

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

Язык программирования Ардуино является реализацией похожей аппаратной платформы “Wiring”, основанной на среде программирования мультимедиа “Processing”.

Это очень интересный проект и главное простой в реализации для моих подписчиков – видеоблогеров . Все что нам нужно – это WiFi-модуль NODEMCU и дисплей сегментный на 8 чисел для вывода количества подписчиков на канале Youtube .

По случаю удалось раздобыть эдакую интересную “уличную” антенну  с весьма многообещающими характеристиками . Она конечно б.у , но и цена на неё была весьма заманчивая . Обошлась в 18 долларов . 

Комплект должен выглядеть вот так : 

Источник: http://www.electronica52.in.ua/proekty-arduino/kak-dobavit-biblioteki-v-arduino-ide-cherez-menedzher-bibliotek

Начинающим на Arduino: Упаковываем конечный автомат в отдельный класс и библиотеку

В прошлой статье про написание конечных автоматов я обещал упаковать наш гениальный код в виде класса на C++ для повторного удобного использования. Делать буду так же на примере своей старой разработки SmartButton. Итак, влезаем в непонятный мир ардуининых библиотек и ООП.

Зачем всё это нужно?

Arduino IDE позволяет использовать синтаксис C++11, оказывается. То есть, там очень развитый объектно-ориентированный язык. Нам же хочется сосредотачиваться на нашем гениальном коде и размазанная по программе лишняя логика частенько мешает сосредоточиться.

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

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

Меню, в свою очередь, управляется кнопками (классы кнопок могут быть разными) или джойстиком (класс). Всё это вместе — класс “дисплей”, который можно объявить в своей программе как:

#include “Display.h”
Display disp(куча параметров и настроек);

Если вы делаете проект не совсем на коленке не кое как и собираетесь что-то потом менять или повторно использовать какие-то свои наработки — лучше оформить сделанное в виде библиотек Arduino. В идеале, конечно же, положить в Github для других людей, если вам не жалко и вы не против, что кто-то ваш код исправит или дополнит.

Раз уж мы в прошлой статье делали кнопочку, давайте её оформим как класс и библиотеку?

Итак, наша задача сделать так, чтобы мы могли в своих скетчах писать:

#include “myButton.h”
myButton b1(4),b2(5),b3(12); // три кнопки на пинах 4, 5 и 12. loop() { b1.run(); b2.run(); b3.run(); // … if (b1.clicked()) doSomething(); // так или другим каким способом, есть варианты. // …
}

Как сделать библиотеку Arduino?

Это просто!

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

Найдите, где лежат ваши скетчи на компьютере. Они лежат каждый в своей папочке, а рядом с ними есть папка libraries (библиотеки). Например, на маке /Users/Пользователь/Documents/Arduino/libraries и на виндоусе c:UsersПользовательДокументыArduinolibraries. Я сам сижу на маке и пути в виндах не знаю. Найдёте.

Вот в этой папке libraries создайте новую папку MyLib, то есть с именем своей библиотеки. Перейдите туда.

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

#ifndef MYLIB_H
#define MYLIB_H #if ARDUINO >= 100 #include
#else #include
#endif // Ваш код здесь #endif

Расскажу, что здесь зачем. Конструкция ниже позволяет включать вашу библиотеку в код несколько раз без ошибок. Лучше использовать название вашей библиотеки большими буквами. Это не сурово прямо обязательно, но все так делают и вы не выделяйтесь. Задача стоит придумать уникальное слово, в нашем случае MYLIB_H, идентификатор для этого заголовочного файла.

#ifndef MYLIB_H
#define MYLIB_H // Ваш код
#endif

То есть, в вашем скетче может оказаться несколько таких строк:

#include “MyLib.h”

Вы скажете “тю, да я, да я слежу, да я…” и будете неправы.

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

Читайте также:  Автоматика на ардуино: преимущества и примеры проектов

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

Следующий важный кусок кода:

#if ARDUINO >= 100 #include
#else #include
#endif

Включает определения из исполняющей системы Arduino UDE. Без этого ваша библиотека просто не скомпилируется.

Всё. Закройте Arduino IDE, Откройте заново. Создайте новый скетч, пропишите там #include “MyLib.h” и ура, ваша библиотека есть и подключена!

Я смотрел, в библиотеке вроде как много файлов должно быть?

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

Чтобы я мог помещать сюда куски своего кода копипастом, я назову библиотеку SmartButton, ладно? Болванку MyLib можно прибить за ненадобностью.

По аналогии с предыдущим пунктом, создаём папку SmartButton, в ней:

  • SmartButton.h — То, что мы будем включать в наши программы. Там будут только определения, без кода.
  • SmartButton.cpp — Программный код класса. Это не скетч! Обратите внимание, что расширение файла cpp (C++).
  • README.md — Файл описания библиотеки “для людей”, то есть, документация. “md” означает MarkDown, то есть с разметкой. Достаточно назвать просто README.
  • library.json — описание библиотеки для Arduino IDE в хитром формате JSON.
  • examples — папка с примерами, которые будут потом видны в Arduino IDE. В ней должны лежать папки с именами примеров, в а них с тем же именем файлы с расширением ino — скетчи.

SmartButton.h

#ifndef SMART_BUTTON_H
#define SMART_BUTTON_H #if ARDUINO >= 100 #include
#else #include
#endif // Можно выше до include переопределить эти значения
#ifndef SmartButton_debounce
#define SmartButton_debounce 10
#endif
#ifndef SmartButton_hold
#define SmartButton_hold 1000
#endif
#ifndef SmartButton_long
#define SmartButton_long 5000
#endif
#ifndef SmartButton_idle
#define SmartButton_idle 10000
#endif class SmartButton { // Это внутренние переменный класса. // Они свои у каждого объекта и конфликта // за имена переменных не будет. // не надо выдумывать для каждой кнопки свои названия. private: byte btPin; // Точно, как мы делали в [предыдущей статье про МКА](https://habrahabr.ru/post/345960/) enum state {Idle, PreClick, Click, Hold, LongHold, ForcedIdle}; enum input {Press, Release, WaitDebounce, WaitHold, WaitLongHold, WaitIdle}; enum state btState = Idle; enum input btInput = Release; unsigned long pressTimeStamp; // Это скрытый метод, его снаружи не видно. private: void DoAction(enum input in); // Это то, чем можно пользоваться. public: // Конструкторы и деструкторы. // То есть то, что создаёт и убивает объект. SmartButton(); SmartButton(int pin); SmartButton(int pin, int mode) {btPin=pin; pinMode(pin,mode);} ~SmartButton(); // В стиле Arduino IDE определим метод begin void begin(int p, int m) {btPin=p; pinMode(p,m);} // Генератор событий для помещения в loop(). void run(); // Методы для переопределения пользователем. public: inline virtual void onClick() {}; // On click. inline virtual void onHold() {}; // On hold. inline virtual void onLongHold() {}; // On long hold. inline virtual void onIdle() {}; // On timeout with too long key pressing. inline virtual void offClick() {}; // On depress after click. inline virtual void offHold() {}; // On depress after hold. inline virtual void offLongHold() {}; // On depress after long hold. inline virtual void offIdle() {}; // On depress after too long key pressing.
}; #endif

Давайте поясню суть затеи. Мы не знаем, что нам будет нужно от кнопки.

Наш МКА умеет находиться в состояниях Клик, Нажатие, Удержание и СлишкомДолгоеУдержание, а так же выходить из этих состояний в состояние Выключен.

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

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

Например, мы захотим сделать кнопку-переключатель, то есть, одно нажатие — включено, другое — выключено. Будем зажигать и гасить светодиод и предоставим функцию isOn() для использования в классическом виде в функции loop().

#include “SmartButton.h” #define LED_PIN (13) // Порождаем наш новый класс от SmartButton
class Toggle : public SmartButton { private: byte sw = 0; // состояние переключателя byte led; // нога для лампочки public: Toggle(byte bt_pin, byte led_pin) : SmartButton(bt_pin) { // конструктор. led=led_pin; }; // Наши методы // Включена кнопка или нет. byte isOn() { return sw; } // Что делать на клик. virtual void onClick() { if (sw) { // Был включен. Выключаем. digitalWrite(led,LOW); // Здесь может быть любой ваш код на выключение кнопки. } else { // Был выключен. Включаем. digitalWrite(led,HIGH); // Здесь может быть любой ваш код на включение кнопки. } sw=!sw; // Переключаем состояние. }
}; // Объявляем переменную bt нашего нового класса. Можно не одну.
Toggle bt(4,LED_PIN); // Нога 4, встроенный светодиод.
Toggle drill(12,8) // Нога 12, светодиод на ноге 8. void loop() { bt.run(); drill.run(); if (bt.isOn()) { // что-то делать } else { // что-то другое делать } if (drill.isOn()) { // что-то делать } else { // что-то другое делать }
}

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

Наш новый класс Toggle тоже можно оформить в виде библиотеки, кстати или положить в отдельный файл Toggle.h рядом с вашим скетчем, вам достаточно будет его подключить директивой #include. Мы так же задаём ногу со светодиодом для подсветки кнопки.

Обратите внимание, что мы просто создали два объекта (bt и drill) нового класса Toggle, а МКА обработки кнопки для нас скрыт и не заботит.

Основываясь на классе SmartButton можно сделать свои классы, что понимают двойной клик, например, водят курсор по меню или поворачивают пулемётную турель медленно-быстрее в зависимости от времени удержания кнопки. Для этого достаточно определить свои методы, описанные в SmartButton.h как virtual. Все определять не обязательно, только нужные вам.

По просьбе целевой аудитории, вот пример класса PressButton, который предоставляет методы:

  • pressed() — кнопка была нажата, можно вызывать много раз.
  • ok() — я понял, слушай кнопку дальше, то есть сброс.

#include “SmartButton.h” #define LED_PIN (13) // Порождаем наш новый класс от SmartButton
class PressButton : public SmartButton { private: byte sw = 0; // состояние переключателя public: PressButton(byte bt_pin) : SmartButton(bt_pin) {}; // конструктор. // Наши методы // Была кликнута кнопка или нет. byte pressed() { return sw; }; // Я всё понял, слушаем кнопку дальше. void ok() { sw=0; }; // Что делать на клик. virtual void onClick() { sw=1; };
}; // Объявляем переменную bt нашего нового класса. Можно не одну.
PressButton bt(4); // Нога 4.
PressButton drill(12) // Нога 12. void loop() { bt.run(); drill.run(); if (bt.pressed()) { // что-то делать bt.ok(); } else { // что-то другое делать } if (drill.pressed()) { // что-то делать if (какое_то_условие) drill.ok(); } else { // что-то другое делать }
}

Таким образом мы получаем две независимо работающие “залипающие” кнопки, которые после нажатия находятся в состоянии pressed пока их не сбросить методом ok().

Если у вас есть меню, вы можете определить методы onClick() у кнопок “вверх” и “вниз”, которые будут вызывать перемещение курсора меню на дисплее с соответствующем направлении.

Определение onHold() у них может вызывать перемещение курсора в начало и конец меню, например.

У кнопки “ентер” можно определить onClick() как выбор меню, onHold() как выход с сохранением, а onLongHold() как выход без сохранения.

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

SmartButton — это просто МКА, это инструмент для реализации поведения ваших кнопок.

Где же скрыта вся магия? Магия кроется в файле SmartButton.cpp

#include “SmartButton.h” // Конструктор и деструктор пустые.
SmartButton::SmartButton() {}
SmartButton::~SmartButton() {}
// Конструктор с инициализацией.
// Он используется чаще всего.
SmartButton::SmartButton(int pin) { btPin = pin; pinMode(pin, INPUT_PULLUP);
} // Машина конечных автоматов сидит здесь: // Обратите внимание – это ровно та же функция,
// Что мы писали в [прошлой статье](https://habrahabr.ru/post/345960/).
// Обратите внимание на вызов виртуальных функций on* и off*.
void SmartButton::DoAction(enum input in) { enum state st=btState; switch (in) { case Release: btState=Idle; switch (st) { case Click: offClick(); break; case Hold: offHold(); break; case LongHold: offLongHold(); break; case ForcedIdle: onIdle(); break; } break; case WaitDebounce: switch (st) { case PreClick: btState=Click; onClick(); break; } break; case WaitHold: switch (st) { case Click: btState=Hold; onHold(); break; } break; case WaitLongHold: switch (st) { case Hold: btState=LongHold; onLongHold(); break; } break; case WaitIdle: switch (st) { case LongHold: btState=ForcedIdle; break; } break; case Press: switch (st) { case Idle: pressTimeStamp=millis(); btState=PreClick; break; } break; }
} // А это наш генератор событий.
// Его надо помещать в loop()
void SmartButton::run() { unsigned long mls = millis(); if (!digitalRead(btPin)) DoAction(Press); else DoAction(Release); if (mls – pressTimeStamp > SmartButton_debounce) DoAction(WaitDebounce); if (mls – pressTimeStamp > SmartButton_hold) DoAction(WaitHold); if (mls – pressTimeStamp > SmartButton_long) DoAction(WaitLongHold); if (mls – pressTimeStamp > SmartButton_idle) DoAction(WaitIdle);
}

Логика местами спорная, я знаю 🙂 Но это работает.

Теперь осталось заполнить файл README описанием вашей библиотеки и заполнить по аналогии файлик library.json, где поля вполне очевидны:

{ “name”: “SmartButton”, “keywords”: “button, abstract class, oop”, “description”: “The SmartButton abstract class for using custom buttons in Arduino sketches.”, “repository”: { “type”: “git”, “url”: “https://github.com/nw-wind/SmartButton” }, “version”: “1.0.0”, “authors”: { “name”: “Sergei Keler”, “url”: “https://github.com/nw-wind” }, “frameworks”: “arduino”, “platforms”: “*”
}

Если у вас нет репозитория, можно эту секцию не указывать.

Ура! Библиотека готова. Можно запаковать папку в ZIP и раздавать друзьям или копировать на другие свои компьютеры.

По аналогии, можно сделать класс для любой МКА. Принцип общий: вы делаете класс, определяете виртуальные методы, которые потом надо будет переопределить, чтобы вставить свой код или готовые методы, если универсальность не требуется.

Что за Github и зачем он мне?

Github — это огромное сообщество программистов. Да, ваш код будет публично светиться на весь интернет, но… любой человек может предложить свои правки к вашему коду. Мне, например, очень помогли с SmartDelay два человека, один из которых сделал свою подобную библиотеку и мы поподсматривали чуть-чуть код друг у друга. Лучше две хорошие библиотеки, чем две глюкавые, правда?

Чтобы поместить вашу библиотеку в Github надо сделать там аккаунт, сгенерить ключ и создать репозиторий с там же именем, что ваша библиотека (папка). Файлы можно загрузить через web-шнтерфейс.

Для установки библиотеки из Github в Arduino IDE достаточно скопировать URL и воспользоваться утилитой git:

Или загрузить ZIP — это будет как раз библиотека Arduino, как и все прочие библиотеки.

Как пользоваться git вообще и Github в частности, есть много статей наверняка. Попробуйте поискать. Если не найдёте, я напишу как им пользуюсь я.

Источник: https://habr.com/post/346006/

Ссылка на основную публикацию
Adblock
detector