Arduino class new

Классы. Урок 25. Ардуино

Привет! Раньше я уже писал как организовать код для Ардуино в функции. Но есть еще один способ программирования основанный на объектах. Естественно, это объектно-ориентированное программирование. А основа любого объекта — это классы. Так что давайте создадим класс для программы на Ардуино и посмотрим, как это работает.

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

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

Классы

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

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

Пишем тестовый класс

Итак, в нашей программе мы хотим включать и выключать светодиод. Это самый первый пример, который мы рассматривали в начале изучения Ардуино. Но теперь, оформим код с учетом концепции объектно-ориентированного программирования.

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

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

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

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

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

Защищенные методы можно использовать из текущего класса или из подклассов. Об этих методах поговорим позже.

Сейчас мы описали наш класс и два публичных метода on() и off(), для включения и выключения светодиода. Также в разделе public мы описали конструктор класса Led(int pin). В него мы будем передавать номер пина при создании объекта Led.

Переменную int _pin мы внесли в раздел private. Она нужна для определения пина на плате Ардуино. Она должны быть приватной, чтобы было невозможно изменить пин после создания объекта. Таким образом, мы защитим использование объекта от ошибок в программе.

Методы класса

Мы описали конструктор и два публичных метода. Но пока, они ничего не делают. Давайте реализуем эти методы в классе.

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

Метод on() выставляет уровень High на пин и, соответственно метод off() выставляет уровень Low на пин. Таким образом, мы сможем зажигать и выключать светодиод.

Использование класса Led

Теперь сохраним наш класс в отдельный файл led.h. Подключим его к программе, создадим объект и посмотрим как использовать методы класса.

Здесь мы подключили файл класса, создали объект класса и передали в конструктор номер пина. А в основном цикле программы мы вызываем метод класса on() и, после небольшой паузы метод off().

Заключение

В этом уроке мы написали первый класс Led для управления светодиодом. Классы помогут нам организовать код в более наглядную и удобную форму. А также позволят нам создавать готовые программные модули и оформлять их как библиотеки.

Источник

Классы и объекты в Arduino

Краткий обзор возможностей объектно-ориентированного программирования в Arduino для начинающих.

Объектно-ориентированное программирование (ООП) основано на работе с объектами,
а не просто с данными, фунциями и переменными.

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

Рассмотрим использование ООП на примере использования датчика влажности почвы для работы
с проектом “Автоматический полив растений” .

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

Прежде чем создать объект, необходимо обозначить новый класс для объекта.

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

Теперь для считывания или указания этих данных можно будет использовать такие записи:

  • название_объекта.pin = … ; // присвоить значение для pin
  • … = название_объекта.data ; // считать значение data

Чтобы объект мог действовать, а не только хранить в себе данные, добавим в описание класса некоторые функции.

Класс нового типа объектов задан. Теперь можно создать наш собственный объект нового класса.

Мы создали объект water класса Sensor.
Теперь зададим номер пина, к которому подключен наш сенсор.

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

Если выполнить для объекта команду water.read(), то значение датчика можно получить из переменной water.data.

Используем для чтения данных последовательный порт.
Полностью программа теперь выглядит так:

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

Источник

Arduino Object Oriented Programming (OOP)

This tutorial is an introduction to Arduino Object Oriented Programming. If you’re already programming using C++ and OOP, and want to start writing Arduino OOP code, you’re in the right place.

I’ll show you through some examples how to re-write some of the most common Arduino tutorials using the OOP way.

At the end of the tutorial you’ll get the complete code so you can directly test on your own Arduino board.

Alright, let’s get started!

Table of Contents

Arduino Object Oriented Programming limitations

Even if Oriented Object Programming is possible with Arduino, you have to know the limitations.

Basically, the Arduino language is a subset of C/C++. You can create classes, use inheritance, composition, and many other nice OOP functionalities, but:

You want to go deeper into OOP for Arduino?

Check out this complete Arduino OOP course.

  • The STL library is not available (not natively, you can still use an external library to get most of the functionalities).
  • You can’t use exceptions.

Hardware setup

Note: it’s OK if you don’t have any Arduino or hardware component available. You can still follow this tutorial and get all the knowledge you need.

We’ll be using the following hardware setup:

  • 1* Arduino Uno board (Any Arduino board will do)
  • 1* breadboard
  • 4* LEDs (any color you want)
  • 4* 220 Ohm resistors (one for each LED)
  • 1* push button
  • 1* 10k Ohm resistor (for the push button)
  • A few male-to-male wires

The goal of the tutorial will be to turn on LED 1 & 3, and turn off LED 2 & 4 when the button is pressed. When the button is not pressed we’ll do the opposite – turn off LED 1 & 3, and turn on LED 2 & 4.

Now let’s go step by step to reach this goal.

A class for a LED

An LED is a very basic component. You setup a digital pin to INPUT mode, and then you just need to set its state to HIGH or LOW.

Let’s create a simple class to wrap the LED functionalities.

You can now use this class to create a Led object.

With the Led class we can hide all the Arduino stuff about digital pins. Note that the object must be created in the global scope if you want to be able to use it in the setup() and loop() functions.

Class for a Button

Let’s now write some OOP code for a push button! The button is a little bit more complex, because we need to add a debounce functionality if we want it to remove the mechanical noise.

Here again, all the complexity is hidden. Once you’ve implemented the debounce functionality for the button inside the class, you don’t need to think about it anymore.

In your program, you just need to create a Button object and check whether it’s pressed or not.

When the button is pressed, we turn on LED 1. As you can see the code in the loop() is quite small and clean.

Complete Arduino Object Oriented code

OOP is great for reusability. Do you remember we added 4 LEDs at the beginning of the tutorial? Well, now that we have a class for a LED, we just need to create additional objects, all the implementation is already done.

Here is the complete code, including the Led class, the Button class, and the main code of the program.

Reorganize your Arduino OOP code

The previous code works well, but everything is in the same file. We want to use OOP for reusability, modularity, readability, etc, but it’s impossible if we write all the code in one file. As your program grows in complexity, so your code length, until you reach a point where the code is so long that you spend more time finding stuff and fixing bugs instead of adding new functionalities.

We’ll separate the code into 3 parts: the Led class, the Button class, and the “main”.

Each class will be on its own independent file. In fact, for one class we’ll have 2 files: one Cpp file (.cpp) and one header file (.h). Your code will become much more readable. The classes you create will be also more reusable as you can include them in every file where you need them.

Note that creating other files for an Arduino program is quite tricky. You must create all your files inside your Arduino program folder. Example: if your program is named Test.ino, then it will be automatically saved on a Test/ folder (the Arduino IDE does that). You’ll have to put all your files in the Test/folder as well, so the Arduino IDE can find them.

Go into the folder of your current Arduino program. Create 4 files:

The files won’t appear in the Arduino IDE right away. You’ll need to close the project, and open it again so the files will show up in tabs on the top.

>> Additional help: Step by Step process to split your Arduino program into different files:

After watching the video, subscribe to the Robotics Back-End Youtube channel so you don’t miss the next tutorials!

And now, here is the complete code for all 5 files. The classes and functionalities are exactly the same as the code we just wrote before.

In this file we just write the class declaration, which is the interface that any client using this class will use. This makes the class much easier to understand and use.

The header guards (first 2 lines, and last line) will make sure that the Led class will not be included more than once, if for example you have multiple #include «Led.h» in other parts of your program.

Led.cpp

Button.h

Same warning as for the Led.h file. Don’t forget to include the Arduino library at the beginning of the file. Also put all your class declaration inside header guards so you won’t include it twice in other parts of your code.

Button.cpp

Well, as you can see, the code is now much clearer and readable. Plus, you could import the Led and Button class in any other part of your application.

For example you could create a class named LedPanel. This class would contain an array of Led objects and handle them. In your “main”, you could just import the LedPanel header file without having to know about the Led class. In fact, why don’t you try to do that to practice more?

You can always create more modules on top of other modules. That’s the power of Object Oriented Programming with Arduino (and not only Arduino by the way).

Arduino Object Oriented: it’s already everywhere

If it’s the first time you use Object Oriented Programming with Arduino, well… Don’t think you’re doing something new! In fact, many of the Arduino already use OOP.

A few OOP library examples:

  • Servo: control a servo motor
  • Serial: communicate between your Arduino board and other devices
  • Wire: communicate though the I2C protocol
  • SevSeg: control a digit 7-segment display
  • EEPROM: store values permanently in your Arduino board

If you’re already familiar with OOP and want to use it in your Arduino programs, don’t hesitate and do it! OOP is certainly not the answer to everything, but if you know how to use it right, there is no reason you couldn’t get its benefits with Arduino.

Did you find this tutorial useful?

If yes, this course is for you:

Did you find this tutorial useful?

Do you want to become better at programming robots, with Arduino, Raspberry Pi, or ROS2?

If yes, subscribe to receive exclusive content and special offers!

Источник

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

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

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

Arduino IDE позволяет использовать синтаксис C++11, оказывается. То есть, там очень развитый объектно-ориентированный язык. Нам же хочется сосредотачиваться на нашем гениальном коде и размазанная по программе лишняя логика частенько мешает сосредоточиться. Взять, например, всякие дисплейчики, кнопочки, датчики и релюшки — у каждого же своя логика, зачем её смешивать с общей логикой программы. Тот же, например, дисплей. У него много полей, статических и изменяемых. Ой, поле — это же класс. Поле может входить в меню (класс меню) или нет, быть часть частью виртуального дисплея (класс), которых на физическом эеране может быть насколько (дисплеи: рабочий, настроек, диагностики и т.п.). Меню, в свою очередь, управляется кнопками (классы кнопок могут быть разными) или джойстиком (класс). Всё это вместе — класс «дисплей», который можно объявить в своей программе как:

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

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

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

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

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

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

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

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

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

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

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

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

Включает определения из исполняющей системы 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 — скетчи.

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

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

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

Как видите, нас совершенно здесь не интересует МКА кнопочки из предыдущей статьи, кода этой кнопки нет, он спрятан. Мы добавили свою функциональность к базовому классу и сделали переключатель по клику. Наш новый класс Toggle тоже можно оформить в виде библиотеки, кстати или положить в отдельный файл Toggle.h рядом с вашим скетчем, вам достаточно будет его подключить директивой #include. Мы так же задаём ногу со светодиодом для подсветки кнопки. Обратите внимание, что мы просто создали два объекта (bt и drill) нового класса Toggle, а МКА обработки кнопки для нас скрыт и не заботит.

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

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

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

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

Если у вас есть меню, вы можете определить методы onClick() у кнопок «вверх» и «вниз», которые будут вызывать перемещение курсора меню на дисплее с соответствующем направлении. Определение onHold() у них может вызывать перемещение курсора в начало и конец меню, например. У кнопки «ентер» можно определить onClick() как выбор меню, onHold() как выход с сохранением, а onLongHold() как выход без сохранения.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Источник

Adblock
detector