Программирование ардуино

Символ окончания строки

Обычно строки оканчиваются нулевым символом (код 0 в ASCII). Это позволяет функциям (таким как Serial.print()) выявлять окончание строки. В противном случае могут считаться байты памяти, не принадлежащие переменной.

Массивы символов, выделяемый под строку, должны иметь один дополнительный элемент для символа конца строки. Именно поэтому Str2 и Str5 должны иметь 8 символом, хотя «arduino» 7 символов — последнему элементу автоматически присваивается символ окончания строки.

Технически возможно объявить строку без символа окончания строки, например, объявить длину массива равной 7 для Str2. Это приведет к некорректной работе функций, оперирующих строками.

Arduino Coding Environment and basic tools

What language is Arduino?

Arduino code is written in C++ with an addition of special methods and functions, which we’ll mention later on. C++ is a human-readable programming language. When you create a ‘sketch’ (the name given to Arduino code files), it is processed and compiled to machine language.

Arduino IDE

The Arduino Integrated Development Environment (IDE) is the main text editing program used for Arduino programming. It is where you’ll be typing up your code before uploading it to the board you want to program. Arduino code is referred to as sketches.

Note: It’s important to use the latest version of Arduino IDE. From time to time, check for updates here.

Arduino code example

As you can see, the IDE has a minimalist design. There are only 5 headings on the menu bar, as well as a series of buttons underneath which allow you to verify and upload your sketches. Essentially, the IDE translates and compiles your sketches into code that Arduino can understand. Once your Arduino code is compiled it’s then uploaded to the board’s memory.

All the user has to do to start compiling their sketch is press a button (a guide to this can be found below).

If there are any errors in the Arduino code a warning message will flag up prompting the user to make changes. Most new users often experience difficulty with compiling because of Arduino’s stringent syntax requirements. If you make any mistakes in your punctuation when using Arduino, the code won’t compile and you’ll be met with an error message.

Serial Monitor and Serial Plotter 

Arduino serial monitor can be opened by clicking on the magnifying glass icon on the upper right side of the IDE or under tools. The serial monitor is used mainly for interacting with the Arduino board using the computer, and is a great tool for real-time monitoring and debugging. In order to use the monitor, you’ll need to use the Serial class.

The code you download from circuito.io has a test section that helps you test each components using the serial monitor, as you can see in the screenshot below:

Arduino serial plotter is another component of the Arduino IDE, which allows you to generate a real-time graph of your serial data. The serial plotter makes it much easier for you to analyze your data through a visual display. You’re able to create graphs, negative value graphs, and conduct waveform analysis.

Debugging Arduino Code and Hardware

Unlike other software programming platforms, Arduino doesn’t have an onboard debugger. Users can either use third-party software, or they can utilize the serial monitor to print Arduino’s active processes for monitoring and debugging.

By using the Serial class, you can print to the serial monitor, debugging comments and values of variables. On most Arduino models, this will be using serial pins 0 and 1 which are connected to the USB port.

Code Structure

Libraries 

In Arduino, much like other leading programming platforms,  there are built-in libraries that provide basic functionality. In addition, it’s possible to import other libraries and expand the Arduino board capabilities and features. These libraries are roughly divided into libraries that interact with a specific component or those that implement new functions.

To import a new library, you need to go to Sketch > Import Library

In addition, at the top of your .ino file, you need to use ‘#include’ to include external libraries. You can also create custom libraries to use in isolated sketches.

Pin Definitions

To use the Arduino pins, you need to define which pin is being used and its functionality. A convenient way to define the used pins is by using:

 ‘#define pinName pinNumber’.

The functionality is either input or output and is defined by using the pinMode () method in the setup section.

Variables

Whenever you’re using Arduino, you need to declare global variables and instances to be used later on. In a nutshell, a variable allows you to name and store a value to be used in the future. For example, you would store data acquired from a sensor in order to use it later. To declare a variable you simply define its type, name and initial value.

It’s worth mentioning that declaring global variables isn’t an absolute necessity. However, it’s advisable that you declare your variables to make it easy to utilize your values further down the line.

Instances

In software programming, a class is a collection of functions and variables that are kept together in one place. Each class has a special function known as a constructor, which is used to create an instance of the class. In order to use the functions of the class, we need to declare an instance for it.

Setup()

Every Arduino sketch must have a setup function. This function defines the initial state of the Arduino upon boot and runs only once.

Here we’ll define the following:

1. Pin functionality using the pinMode function
2. Initial state of pins
3. Initialize classes
4. Initialize variables
5. Code logic

Loop()

The loop function is also a must for every Arduino sketch and executes once setup() is complete. It is the main function and as its name hints, it runs in a loop over and over again.  The loop describes the main logic of your circuit.

For example:

Note: The use of the term ‘void’ means that the function doesn’t return any values.

Нам понадобится

• Отладочная плата AVR. Предпочтительно Arduino UNO/Piranha UNO или любая другая плата AVR, совместимая с Ethernet шилдом. Если Ваша панель использует большое количество переменных и/или Ваш скетч использует большое количество библиотек, необходимо использовать отладочную плату на базе микроконтроллера с большей статической и динамической памятью, такую как Arduino MEGA или Piranha ULTRA
• Ethernet шилд W5500 (если Вы используете шилд на базе чипа ENC28J60, необходимо использовать отладочную плату на базе микроконтроллера с большей статической и динамической памятью, такую как Arduino MEGA или Piranha ULTRA, при этом необходимо скачать и установить последнюю версию библиотеки UIPEthernet и изменить в скетче Ethernet.h на UIPEthernet.h).
• Провод RJ45-RJ45 категории cat5e.
• Маршрутизатор со свободным гнездом RJ-45 LAN.
• Подключение к сети Интернет.

Время обработки и размер разных типов данных в Arduino IDE

Сердце платы Arduino — Atmel ATmega328P, 8-ми битный процессор, в котором не предусмотренная встроенная функция поддержки чисел с плавающей запятой. Для того, чтобы использовать типы данных больше чем 8 бит, компилятор должен обеспечить место для отдельного куска кода с большим объемом данных, обработать его (на что понадобится некоторое время) и поместить результат обработки в место, где он используется.

То есть, максимальная продуктивность будет при обработке 8-ми битных значений и минимальная — при работе со значениями с плавающей запятой. Рассмотрим пример скетча для Arduino, в котором проводятся простые математические операции. В программе можно легко поменять тип данных и сделать аналогичные расчеты, чем мы и займемся.

Сначала давайте загрузим скетч на ваш Arduino Uno и посмотрим, какой результат появится в консоли серийного монитора:

Давайте разбираться с результатами.

Во-первых, проверьте размер скомпилированного кода. С использованием типа данных bytes мы вышли на размер скетча в 2458 байта. Не так уж много и большая часть — это операция вывода данных в окне серийного монитора.

Во-вторых, давайте взглянем на вывод данных в окне серийного монитора. Почему вместо чисел отображаются квадраты? Это происходит из-за того, что функция Serial.print( ) в Arduino изменяет режим своей работы в зависимости от типа данных, которые ей передаются. Для 8-ми битных значений (это может быть и char и byte), функция отобразит значение в бинарном виде. При этом консоль серийного монитора интерпретирует эти данные в виде ASCII символа, а ASCII символы для 1,2 и 3 — это ‘START OF HEADING’, ‘START OF TEXT’, и ‘END OF TEXT’. Согласитесь, на практике это не самый удобный вариант, не лучше ли отобразить это с помощью одного символа? Отсюда и появляется квадрат: консоль серийного монитора сообщает вам примерно следующее: «я без понятия как это отобразить, так что вот вам квадрат». Итак, урок первый при работе с различными типами данных Arduino: для того, чтобы отобразить 8-ми битное значение в десятичном формате с использованием функции Serial.print( ), при вызове функции надо добавить DEC:

Serial.print(x, DEC);

Ну и в-третьих, посмотрите на строку, в которой отображено значение «Elapsed time» (Затраченное время). Для того, чтобы оценить затраченное время, используем функцию micros( ), которая выдает достаточно точный результат при оценке времени выполнения запрограммированных операций. Как вы можете заметить, операция суммирования двух 8-ми битных значений заняла около 4 микросекунд процессорного времени.

Тестируем разные типы данных (Умножение/Деление)

Теперь давайте взглянем что будет в случае «более сложных» математических операций — умножение и деление.

Ниже представлены несколько скриншотов результатов операции умножения:

Оцените затраченное время: 4 миллисекунды для byte, 8 для int или long и 12 для float. Итак, умножение явно поддерживается на уровне встроенных инструкций в нашем процессоре на Arduino. В результате операция умножения обрабатывается достаточно быстро. А что же будет с делением?

Упс. Деление сданных типа byte не так уж критично по времени — 16 миллисекунд, но long тянет 48?! Как-то не очень впечатляет. Оказывается, в процессоре Atmega, которым оснащается Arduino, нет встроенных инструкций для операций деления и компилятору приходится каждый раз ее генерировать. Так что наш последний урок при работе с разными типами данных Arduino: не все математические операции отрабатывают по подобным алгоритмам. Операция деления занимает гораздо больше времени чем умножение или нахождение суммы (или операция нахождения разности, хотя это по сути тоже, что и сложение только со знаком минус). А более сложные операции вроде нахождения квадратного корня или синуса угла займут еще больше времени. Порой обработка результатов длится настолько долго, что гораздо проще просто получить список необходимых значений с помощью Arduino, передать их на персональный компьютер и уже там найти нужные вам синусы, косинусы, тангенсы, квадратные корни и т.д. и т.п.

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

Оставляйте Ваши комментарии, вопросы и делитесь личным опытом ниже. В дискуссии часто рождаются новые идеи и проекты!

Справочник языка Ардуино

Создание строк в ардуино с помощью String

В ардуино у нас есть несколько способов создать строку, приведем основные:

• char myCharStr = “Start”;  – массив типа char с завершающим пустым символом;
• String myStr = “Start”; – объявляем переменную, создаем экземпляр класса String и записываем в него константу-строку.
• String myStr = String(“Start”); – аналогичен предыдущему: создаем строку из константы
• String myStr(myCharStr); – создаем объект класса String с помощью конструктра, принимающего на вход массив типа char и создающего из char String.
• String myStr = String(50); – создаем строку из целого числа (преобразование int to string).
• String myStr = String(30, H); – создаем строку – представление числа в 16-чной системе (HEX to String)
• String myStr = String(16, B); – создаем строку – представление числа в двоичной системе (Byte to String).

Каждый раз, когда мы объявляем в коде строку с использованием двойных кавычек, мы создаем неявный объект класса String, являющийся константой. При этом обязательно использование именно двойных кавычек: “String” – это строка. Одинарные кавычки нужны для обозначения отдельных символов. ‘S’ – это символ.

Тестируем разные типы данных (Сумма)

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

Теперь загрузите новый скетч на ваш Arduino. Проверьте размер после компиляции: 2488 байт при использовании типа данных int. Напомним, что при использовании byte у нас было 2458 байта. Не намного больше, но это всего лишь три переменные! Напомним, что тип данных int занимает 16 байт, а не 8 как, например, byte. Теперь откройте окно серийного монитора, на котором вы должны увидеть что вроде:

Следующее: в этот раз данные отобразились корректно. Это из-за того, что новый тип данных, который мы использовали, int, корректно интерпретируется компилятором как числовой тип и функция Serial.print( ) правильно отображает данные в консоли. Итак, второй урок при работе с разными типами данных Arduino: если вы хотите отправить бинарный эквивалент данных типа числового, скажем, для передачи данных на другой компьютер, а не для отображения в консоли, используйте функцию Serial.write( ).

Теперь давайте посмотрим на строку “Elapsed time”. Мы потратили 12 микросекунд — в три раза больше времени! Почему такая разница? Как мы уже упоминали выше, у нас 8-ми битный процессор, а это значит, что для математических операций с 16-ти битными числами, нам потребуются дополнительная обработка данных.

Теперь давайте займемся типом данных long. Повторите код, заменив тип данных int на long. Загрузите скетч на Arduino и откройте ваш серийный монитор:

Смотрим на размер скетча: 2516 байт, на 28 байт больше, чем при использовании int и на 58 больше, чем с использованием типа данных byte.

Смотрим дальше. Время, которое была затрачено на обработку данных уменьшилось! С 12 до 8 секунд! Почему? Это не логично! Это третий урок, который надо вынести: не всегда то, что вы предполагаете на самом деле происходит. Вероятно, подобное происходит благодаря оптимизации самого компилятора.

Итак, последнее, что мы должны рассмотреть — типы данных с плавающей запятой. Для этого замените тип данных long на float

Загрузите скетч на Arduino и обратите внимание на размер: 3864 байта! Используя тип данных с плавающей запятой вы заставили компилятор обрабатывать значения после запятой. А это дополнительный большой кусок кода

Урок четвертый — не используйте значения с плавающей запятой, если только вы на 60% не уверены, что без этого типа данных вам не обойтись. Например, если вы подключили сенсор и получаете значение с аналогового входа вроде 536, гораздо информативнее будет преобразовать это значение в вольты и отобразить пользователю что-то вроде 2.26 В.

Теперь взгляните на время обработки данной программы: опять 12 миллисекунд. Кстати, заметьте, что значения x, y, z отобразились с двумя нулями в десятичной части. Если вам надо больше (или меньше) значков после запятой, вы можете добавить их с помощью команды:

Serial.print(x, 3); // отображает x с тремя знаками в дробной части.

Синтаксис

Ниже приведены варианты объявления и присвоения строк:

1 char Str115]; // Объявление массива символов без присваивания значений
2 char Str28 = {'a', 'r', 'd', 'u', 'i', 'n', 'o'}; //  Объявление массива символов и присвоение значений всем элементам, кроме последнего, компилятор Arduino автоматически добавит символ конца строки
3 char Str38 = {'a', 'r', 'd', 'u', 'i', 'n', 'o', '\0'}; // Явно объявлен завершающий символ
4 char Str4  = "arduino"; // Инициализирование массива строковой константой в двойных кавычках. Компилятор автоматически задаст требуемый размер на массив, равный количеству символов плюс завершающий символ
5 char Str58 = "arduino"; // Инициализирование массива с явным заданием размера и присвоением строковой константы
6 char Str615 = "arduino"; // Инициализирование массива с явным заданием дополнительного размера (с запасом), фактически превышающего размер строковой константы при начальном присвоении

What is inside of an enum

This code example illustrates the simplicity of an enum. We will print out the values for each of our states.

enum blinkStates {
  BLINK_DIS, // blink disable
  BLINK_EN, // blink enable
  LED_ON, // we want the led to be on for interval
  LED_OFF // we want the led to be off for interval
};

enum blinkStates ledState;

void setup() {
  delay(1000);
  Serial.begin(9600);
  Serial.println(F("---------"));
  Serial.print(F("BLINK_DIS = "));
  Serial.println(BLINK_DIS);

  Serial.print(F("BLINK_EN = "));
  Serial.println(BLINK_EN);

  Serial.print(F("LED_ON = "));
  Serial.println(LED_ON);

  Serial.print(F("LED_OFF = "));
  Serial.println(LED_OFF);
}

void loop() { }
// Code by 
// More at: https://www.baldengineer.com/state-machine-with-enum-tutorial.html

When I run it on my Arduino Uno and my MSP430 based Launchpad, I get the following results.

---------
BLINK_DIS = 0
BLINK_EN = 1
LED_ON = 2
LED_OFF = 3

So what you can see with this example is that C is using integers to represent our simple to use names.

Тестируем разные типы данных (Умножение/Деление)

Теперь давайте взглянем что будет в случае «более сложных» математических операций — умножение и деление.

Ниже представлены несколько скриншотов результатов операции умножения:

Оцените затраченное время: 4 миллисекунды для byte, 8 для int или long и 12 для float. Итак, умножение явно поддерживается на уровне встроенных инструкций в нашем процессоре на Arduino. В результате операция умножения обрабатывается достаточно быстро. А что же будет с делением?

Упс. Деление сданных типа byte не так уж критично по времени — 16 миллисекунд, но long тянет 48?! Как-то не очень впечатляет. Оказывается, в процессоре Atmega, которым оснащается Arduino, нет встроенных инструкций для операций деления и компилятору приходится каждый раз ее генерировать. Так что наш последний урок при работе с разными типами данных Arduino: не все математические операции отрабатывают по подобным алгоритмам. Операция деления занимает гораздо больше времени чем умножение или нахождение суммы (или операция нахождения разности, хотя это по сути тоже, что и сложение только со знаком минус). А более сложные операции вроде нахождения квадратного корня или синуса угла займут еще больше времени. Порой обработка результатов длится настолько долго, что гораздо проще просто получить список необходимых значений с помощью Arduino, передать их на персональный компьютер и уже там найти нужные вам синусы, косинусы, тангенсы, квадратные корни и т.д. и т.п.

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

Оставляйте Ваши комментарии, вопросы и делитесь личным опытом ниже. В дискуссии часто рождаются новые идеи и проекты!

Область видимости переменных в Arduino

Как мы хорошо знаем, в любом языке программирования переменные служат для хранения каких-либо данных. У каждой переменной есть название и тип, а для создания переменной надо просто указать вместе и то и другое. Например, написав в коде “int sum;” мы укажем компилятору, что нужно создать ячейку памяти с типом данных int и названием sum.

Создав переменную, мы можем использовать ее для сохранения и считывания значений. Но остается вопрос – где именно мы можем это сделать? Согласно правилам Arduino (на самом деле, эти правила заложены в основу C++), у каждой переменной есть свой ареал обитания – область, где с ней можно работать, т.е. сохранять значения и считывать их. И программист должен обязательно понимать, где заканчивается эта область.

random — генерация случайных чисел Ардуино

Функция random (min, max) позволяет вернуть псевдослучайное число в диапазоне, заданном значениями min и max. Разберем примеры с разными типами данных.

Arduino random int

В представленном примере выбран тип данных byte, хранящий целые числа в диапазоне от 0 до 250. Можно использовать и другие типы данных: int, long, unsigned long, unsigned int и другие. Соответственно задается нужный диапазон (min, max).

byte data;

void setup() {
   Serial.begin(9600);
}

void loop() {
   data = random(100, 200); // ардуино рандомное число в диапазоне
   Serial.println(data);
   delay(250);
}

Arduino random float

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

float data;
float data1;
float data2;

void setup() {
   Serial.begin(9600);
}

void loop() {
   data1 = random(0, 10);        // генерируем целые числа
   data1 = random(0, 100);      // генерируем числа после запятой
   data = data1 + data2 / 100; // складываем полученные значения
   Serial.println(data);
   delay(250);
}

Arduino random bool

Если нужна случайная переменная boolean, которая может принимать только два значения true или false. То можно генерировать случайное true/false с заданной вероятностью. Просто присваиваем переменной bool результат функции random, в которой указываем число, обратное вероятности получения false. Пример:

bool data;

void setup() {
   Serial.begin(9600);
}

void loop() {
   data = random(5); // переменная data получит значение 0 с вероятностью 1/5
   Serial.println(data);
   delay(250);
}

Resources and Going Further

I’m going to leave it here for now. I hope I’ve demonstrated clearly the benefits of using appropriate data types for your variables. The next tutorial will go into some of the really ugly pitfalls that are hiding in mixing data types and using INAPPROPRIATE data types — for instance, data types that are too small for the largest number that you may encounter.

All of the context for these operations comes from the compiler, and the directions for the context get to the compiler from the user. You, the programmer, tell the compiler that THIS value is an integer and THAT value is a floating point number. The compiler, then, is left trying to figure out what I mean when I say «add this integer to that floating point». Sometimes that’s easy, but sometimes it’s not. And sometimes it SEEMS like it SHOULD be easy, but it turns out to yield results you might not anticipate.

Here’s some further reading you may want to explore with your new knowledge of data types:

• Digital Logic
• How to read a schematic
• Logic Levels
• Binary

Общая информация об Arduino

Arduino обрели особенно сильную популярность среди людей, которые только начинают заниматься электроникой. На то есть несколько причин. В отличие от большинства предшественников, Arduino не требует дополнительного оборудования (программатора) для загрузки кода на плату — используется простой USB-кабель. Оболочка для программирования — Arduino IDE использует упрощенную версию C++, что облегчает процесс обучения для новичков. Кроме того, Arduino использует стандартизированный форм фактор для большинства своих плат, благодаря чему появился целый комплект дополнительных «шилдов».

Arduino Uno показана на рисунке ниже:

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

Оболочка Arduino IDE:

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

В этой статье мы остановимся на следующих основных моментах:

• Какие проекты можно реализовать с Arduino
• Основные узлы плат Arduino
• Номенклатура самых удачных моделей Arduino
• Дополнительные (периферийные) устройства для Arduino

Рекомендуем также дополнительно почитать

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

• Что такое электричество?
• Закон Ома
• Электрическая цепь
• Интегральная схема (микросхема)
• Аналоговый сигнал
• Цифровой сигнал

Характеристика основных типов данных в Arduino IDE

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

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

Обратите внимание, сто переменные типа signed дают возможность оперировать положительными и отрицательными числами, а переменные типа unsigned допускают только работу с позитивными значениями

• boolean (8 бит) — простое логическое true/false (правда/ложь)
• byte (8 бит) — unsigned число в диапазоне от 0-255
• char (8 бит) — signed число в диапазоне от -128 до 127. В некоторых случаях компилятор будет интерпретировать этот тип данных как символ, что может привести к неожиданным результатам.
• unsigned char (8 бит) — то же что и ‘byte’; для ясности кода рекомендуется вместо этого типа данных использовать ‘byte’.
• word (16 бит) — unsigned число в диапазоне от 0 до 65535
• unsigned int (16 бит)- то же, что и ‘word’. Рекомендуется заменять типом данных ‘word’ для сокращения кода и ясности
• int (16 бит) — signed число в диапазоне от -32768 до 32767. Один из самых распространенных типов данных, который очень часто используется для объявления переменных в скетчах-примерах для Arduino, встроенных в Arduino IDE
• unsigned long (32 бита) — unsigned число в диапазоне от 0-4,294,967,295. Чаще всего этот тип данных используется для хранения результатов функции millis( ), которая возвращает количество миллисекунд, на протяжении которого работал ваш код.
• long (32 бита) — signed число в диапазоне от -2,147,483,648 до 2,147,483,647
• float (32 бита) — signed число в диапазоне от -3.4028235E38 до 3.4028235E38. Числа с плавающей запятой не характерны для Arduino и компилятору придется прилично попотеть, чтобы их обработать. Так что рекомендуется по возможности их избегать. Более детально мы затронем этот вопрос позже.

В этой статье не рассматриваются arrays (массивы), pointers (указатели) и strings (строки); это специальные типы данных, с более сложной концепцией, которую надо рассматривать отдельно.

Схема подключения Arduino.

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

Можно использовать встроенный светодиод на плате Arduino UNO, который подключен к 13 пину и на плате обозначается буквой L. Но данный пример не наглядный и будет сложно проверить и понять преимущества использования переменных. Вот почему желательно использовать схему подключения внешнего светодиода.

Цель урока: использование переменных в проектах на Arduino.

Рассмотрим код из первого урока: Мигаем светодиодом с помощью Arduino.

void setup()
{
  pinMode(2, OUTPUT);
}
void loop()
{
  digitalWrite(2, HIGH);
  delay(500); // Wait for 1000 millisecond(s)
  digitalWrite(2, LOW);
  delay(500); // Wait for 1000 millisecond(s)
}

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

Применение переменных типа int в Arduino.

Использование переменных в проектах на Arduino помогает упростить код и сделать его более гибким. Сегодня в Arduino уроке мы рассмотрим переменные типа int (от англ. integer – целое число) один их наиболее часто используемых типов данных для хранения чисел. int занимает 2 байта памяти, и может хранить числа от -32 768 до 32 767 (от -2^15 до 2^15-1).

Для того, чтобы использовать переменную нужно её объявить, для этого пишем тип переменной в нашем случае int, название переменой ( в названии можно использовать латинские буквы, цифры и символы -,_), и указываем какое значение будет хранить переменная. Если не указать, чему равна переменная она будет равна 0.

int led = 2;

Затем нам нужно заменить пин подключения 2 на переменную.

pinMode(led, OUTPUT); 
... 
digitalWrite(led, HIGH); 
digitalWrite(led, LOW);

Сейчас достаточно изменить значение переменой led и подключить светодиод к выбранному пину. Например, если int led = 5; то схема подключения будет выглядеть вот так:

Arduino

int tim = 500; 
int tim2 =300;

Переменная tim хранит время свечения светодиода, tim2 – время, сколько светодиод не светит.

Использовать переменные будем следующим образом:

void loop()
{
  digitalWrite(led, HIGH);
  delay(tim); // Ждем
  digitalWrite(led, LOW);
  delay(tim2); // Ждем
}

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

Загружаем код в Arduino UNO.

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

Нажмите на кнопку «Загрузить», после удачной компиляции и загрузки кода в плату, вы увидите надпись «Загрузка завершена».

Если у вас возникли сложности с загрузкой кода, посмотрите эту статью:

Понравился урок 2, Переменные в Arduino IDE? Не забудь поделиться с друзьями в соц. сетях.

А также подписаться на наш канал на YouTube, вступить в группу , в группу на .

Спасибо за внимание!

Технологии начинаются с простого!

Файлы для скачивания

Скачивая материал, я соглашаюсь с
Правилами скачивания и использования материалов.

Introduction

Computers, including the Arduino, tend to be highly data agnostic. At their core, the heart of the device is an arithmetic-logic unit (ALU), which performs (fairly) simple operations on locations in memory: R1+R2, R3*R7, R4&R5, etc. The ALU doesn’t care what that data represents to a user, be it text, integer values, floating point values, or even part of the program code.

All of the context for these operations comes from the compiler, and the directions for the context get to the compiler from the user. You, the programmer, tell the compiler that this value is an integer and that value is a floating point number. The compiler, then, is left trying to figure out what I mean when I say «add this integer to that floating point.» Sometimes that’s easy, but sometimes it’s not. And sometimes it seems like it should be easy, but it turns out to yield results you might not anticipate.

This tutorial will cover the basic data types available in Arduino, what they’re typically used for, and will highlight the effects of using different data types on the size and performance speed of your programs.

Похожие записи:

Как выставить зажигание с помощью стробоскопа? Сигнализация действия защиты и автоматики Подключение потолочного светильника со светодиодами Маркировка smd компонентов: кодовые обозначения Как сделать веб-приложение для вашего собственного bluetooth low energy девайса? Как подключить усилитель в машине