Arduino операторы сравнения: Оператор If | Аппаратная платформа Arduino

Содержание

Операторы сравнения | Arduino технологии

== (равно)

Оператор равенства. Возвращает true, если a равно b, в противном случае возвращает false.

if (a == b) {
  // код при условии что a равно b
} else {
  // код при условии что a не равно b
}

При использовании в управляющих операторах if и while нужно быть осторожным и не перепутать его с оператором присваивания = (одиночный символ равенства), например:

if (a = b) {
  // код
}

В данном примере код внутри условного оператора будет выполнен при всех значениях переменной b, отличных от 0. Дело в том, что оператор присваивания возвращает присвоенное значение (то есть значение b) и оно преобразуется к типу bool. Поэтому при всех ненулевых b оно будет преобразовано к true, а при нулевом значении - к false.

Мало того, что отработает код, который отработать не должен был. Также и будет изменено значение переменной a.

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

if (5 == a) {
  // код
}

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

Однако при таком подходе код становится менее "читабельным", а также он не поможет при сравнении двух переменных.

!= (не равно)

Оператор неравенства. Возвращает true когда a не равно b, и false, когда a равно b.

if (a != b) {
  // код при условии что a не равно b
} else {
  // код при условии что a равно b
}
< (меньше)

Оператор "меньше". Возвращает true когда первый аргумент меньше второго и false, когда первый аргумент равен второму или больше него.

if (a < b) {
  // код при условии что a меньше b
} else {
  // код при условии что a равно b или a больше b
}
> (больше)

Оператор "больше". Возвращает true когда первый аргумент больше второго и false, когда первый аргумент равен второму или меньше него.

if (a > b) {
  // код при условии что a больше b
} else {
  // код при условии что a равно b или a меньше b
}
<= (меньше или равно)

Оператор "меньше или равно". Возвращает true когда первый аргумент меньше второго или равен второму и false, когда первый аргумент больше второго.

if (a <= b) {
  // код при условии что a меньше или равно b
} else {
  // код при условии что a больше b
}
>= (больше или равно)

Оператор "больше или равно". Возвращает true когда первый аргумент больше второго или равен второму и false, когда первый аргумент меньше второго.

if (a >= b) {
  // код при условии что a больше или равно b
} else {
  // код при условии что a меньше b
}

Arduino - операторы сравнения - it-brain.online

Предположим, что переменная A содержит 10, а переменная B содержит 20, тогда -

Имя оператора Оператор простой Описание пример
равно = = Проверяет, равно ли значение двух операндов или нет, если да, тогда условие становится истинным. (A == B) не соответствует действительности
не равно ! знак равно Проверяет, является ли значение двух операндов равным или нет, если значения не равны, тогда условие становится истинным. (A! = B) верно
меньше, чем < Проверяет, меньше ли значение левого операнда, чем значение правого операнда, если да, тогда условие становится истинным. (A <B) верно
больше чем > Проверяет, больше ли значение левого операнда, чем значение правого операнда, если да, тогда условие становится истинным. (A> B) не соответствует действительности
меньше или равно <= Проверяет, меньше ли значение левого операнда или равно значению правого операнда, если да, тогда условие становится истинным. (A <= B) верно
больше или равно > = Проверяет, больше ли значение левого операнда или равно значению правого операнда, если да, тогда условие становится истинным. (A> = B) не соответствует действительности

пример

void loop () { 
   int a = 9,b = 4
   bool c = false;
   if(a == b)
      c = true;
   else
      c = false;

   if(a != b)
      c = true;
   else
      c = false;
   
   if(a < b)
      c = true;
   else
      c = false;
   
   if(a > b)
      c = true;
   else
      c = false;
   
   if(a <= b)
      c = true;
   else
      c = false;
   
   if(a >= b)
      c = true;
   else
      c = false;
}

Результат

c = false
c = true
c = false
c = true
c = false
c = false

arduino_operators.htm

Arduino - Операторы - CoderLessons.com

Оператор — это символ, который указывает компилятору выполнять определенные математические или логические функции. Язык C богат встроенными операторами и предоставляет следующие типы операторов:

  • Арифметические Операторы
  • Операторы сравнения
  • Булевы операторы
  • Битовые операторы
  • Составные операторы

Арифметические Операторы

Предположим, что переменная A содержит 10, а переменная B содержит 20, тогда —

Показать пример

Имя оператора Оператор простой Описание пример
оператор присваивания знак равно Сохраняет значение справа от знака равенства в переменной слева от знака равенства. A = B
прибавление + Добавляет два операнда А + Б даст 30
вычитание Вычитает второй операнд из первого A — B даст -10
умножение * Умножьте оба операнда А * Б даст 200
деление / Разделите числитель на знаменатель Б / у даст 2
по модулю % Оператор модуля и остаток от целочисленного деления B% A даст 0

Операторы сравнения

Предположим, что переменная A содержит 10, а переменная B содержит 20, тогда —

Показать пример

Имя оператора Оператор простой Описание пример
равно == Проверяет, равно ли значение двух операндов или нет, если да, тогда условие становится истинным. (A == B) не соответствует действительности
не равно знак равно Проверяет, является ли значение двух операндов равным или нет, если значения не равны, тогда условие становится истинным. (A! = B) верно
меньше, чем < Проверяет, меньше ли значение левого операнда, чем значение правого операнда, если да, тогда условие становится истинным. (A <B) верно
лучше чем > Проверяет, больше ли значение левого операнда, чем значение правого операнда, если да, тогда условие становится истинным. (A> B) не соответствует действительности
меньше или равно <= Проверяет, меньше ли значение левого операнда или равно значению правого операнда, если да, тогда условие становится истинным. (A <= B) верно
больше или равно > = Проверяет, больше ли значение левого операнда или равно значению правого операнда, если да, тогда условие становится истинным. (A> = B) не соответствует действительности

Булевы операторы

Предположим, что переменная A содержит 10, а переменная B содержит 20, тогда —

Показать пример

Имя оператора Оператор простой Описание пример
а также && Называется логический оператор И. Если оба операнда отличны от нуля, тогда условие становится истинным. (A && B) верно
или же || Вызывается логическим оператором ИЛИ. Если любой из двух операндов не равен нулю, тогда условие становится истинным. (A || B) верно
не ! Вызывается логическим оператором НЕ. Используйте для изменения логического состояния своего операнда. Если условие истинно, то оператор Логический НЕ будет делать ложь. ! (A && B) неверно

Битовые операторы

Предположим, что переменная A содержит 60, а переменная B содержит 13, тогда —

Показать пример

Имя оператора Оператор простой Описание пример
а также & Двоичный оператор AND немного копирует результат, если он существует в обоих операндах. B) даст 49, который является 0011 0001
не ~ Оператор дополнения двоичных единиц является унарным и имеет эффект «переворачивания» битов. (~ A) даст -60, что составляет 1100 0011
сдвиг влево << Двоичный оператор левого сдвига. Значение левого операнда перемещается влево на количество битов, указанное правым операндом. << 2 даст 240, что составляет 1111 0000
сдвиг вправо >> Оператор двоичного правого сдвига. Значение левого операнда перемещается вправо на количество битов, указанное правым операндом. A >> 2 даст 15, что 0000 1111

Составные операторы

Предположим, что переменная A содержит 10, а переменная B содержит 20, тогда —

Показать пример

Плата Intel® Edison для Arduino* Спецификации продукции

Дата выпуска

Дата выпуска продукта.

Ожидается задержка

Ожидается снятие с производства — это оценка времени, когда для продукции начнется процесс снятия с производства. Уведомление о снятии продукции с производства (PDN), опубликованное в начале процесса, будет включать в себя все сведения об основных этапах снятия с производства. Некоторые подразделения могут сообщать сведения о сроках снятия с производства до публикации PDN. Обратитесь к представителю Intel для получения информации о сроках снятия с производства и вариантах продления сроков.

Кол-во соединений QPI

QPI (Quick Path Interconnect) обеспечивающий соединяет высокоскоростное соединение по принципу точка-точка при помощи шины между процессором и набором микросхем.

Поддерживаемая частота системной шины

FSB (системная шина) непосредственно соединяет процессор и блока контроллеров памяти (MCH).

Четность системной шины

Четность системной шины обеспечивает возможность проверки ошибок в данных, отправленных в FSB (системная шина).

Литография

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

Доступные варианты для встраиваемых систем

Доступные варианты для встраиваемых систем указывают на продукты, обеспечивающие продленную возможность приобретения для интеллектуальных систем и встроенных решений. Спецификация продукции и условия использования представлены в отчете Production Release Qualification (PRQ). Обратитесь к представителю Intel для получения подробной информации.

Макс. объем памяти (зависит от типа памяти)

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

Типы памяти

Процессоры Intel® поддерживают четыре разных типа памяти: одноканальная, двухканальная, трехканальная и Flex.

Расширения физических адресов

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

Макс. число модулей DIMM

Модуль памяти DIMM - это набор микросхем DRAM (Dynamic Random-Access Memory), расположенных на небольших печатных платах.

Поддержка памяти ECC

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

Версия USB

USB (Универсальная последовательная шина) - это технология подключения отраслевого стандарта для подключения периферийных устройств к компьютеру.

Кол-во последовательных портов

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

Интегрированный сетевой адаптер

Интегрированный сетевой адаптер предполагает наличие MAC-адреса встроенного Ethernet-устройства Intel или портов локальной сети на системной плате.

Firewire

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

Новые команды Intel® AES

Команды Intel® AES-NI (Intel® AES New Instructions) представляют собой набор команд, позволяющий быстро и безопасно обеспечить шифрование и расшифровку данных. Команды AES-NI могут применяться для решения широкого спектра криптографических задач, например, в приложениях, обеспечивающих групповое шифрование, расшифровку, аутентификацию, генерацию случайных чисел и аутентифицированное шифрование.

Технология Intel® Trusted Execution

Технология Intel® Trusted Execution расширяет возможности безопасного исполнения команд посредством аппаратного расширения возможностей процессоров и наборов микросхем Intel®. Эта технология обеспечивает для платформ цифрового офиса такие функции защиты, как измеряемый запуск приложений и защищенное выполнение команд. Это достигается за счет создания среды, где приложения выполняются изолированно от других приложений системы.

Технология Anti-Theft

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

Arduino 101* Спецификации продукции

Дата выпуска

Дата выпуска продукта.

Ожидается задержка

Ожидается снятие с производства — это оценка времени, когда для продукции начнется процесс снятия с производства. Уведомление о снятии продукции с производства (PDN), опубликованное в начале процесса, будет включать в себя все сведения об основных этапах снятия с производства. Некоторые подразделения могут сообщать сведения о сроках снятия с производства до публикации PDN. Обратитесь к представителю Intel для получения информации о сроках снятия с производства и вариантах продления сроков.

Кол-во соединений QPI

QPI (Quick Path Interconnect) обеспечивающий соединяет высокоскоростное соединение по принципу точка-точка при помощи шины между процессором и набором микросхем.

Четность системной шины

Четность системной шины обеспечивает возможность проверки ошибок в данных, отправленных в FSB (системная шина).

Встроенная система хранения

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

Литография

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

Расчетная мощность

Расчетная тепловая мощность (TDP) указывает на среднее значение производительности в ваттах, когда мощность процессора рассеивается (при работе с базовой частотой, когда все ядра задействованы) в условиях сложной нагрузки, определенной Intel. Ознакомьтесь с требованиями к системам терморегуляции, представленными в техническом описании.

Доступные варианты для встраиваемых систем

Доступные варианты для встраиваемых систем указывают на продукты, обеспечивающие продленную возможность приобретения для интеллектуальных систем и встроенных решений. Спецификация продукции и условия использования представлены в отчете Production Release Qualification (PRQ). Обратитесь к представителю Intel для получения подробной информации.

Доступная память

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

Типы памяти

Процессоры Intel® поддерживают четыре разных типа памяти: одноканальная, двухканальная, трехканальная и Flex.

Версия USB

USB (Универсальная последовательная шина) - это технология подключения отраслевого стандарта для подключения периферийных устройств к компьютеру.

Кол-во последовательных портов

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

Интегрированный сетевой адаптер

Интегрированный сетевой адаптер предполагает наличие MAC-адреса встроенного Ethernet-устройства Intel или портов локальной сети на системной плате.

Firewire

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

Интегрированный адаптер IDE

Интерфейс IDE — это стандарт интерфейса для соединения устройств хранения, который указывает на то, что контроллер диска интегрирован в диск, а не является отдельным компонентом на материнской плате.

Инфракрасный датчик приемника

Указывает на наличие инфракрасного датчика ресивера на продуктах Intel® NUC или возможность предыдущих системных плат Intel® принимать инфракрасный датчик ресивера через разъем.

Дополнительные разъемы

Дополнительные разъемы позволяют использовать дополнительные интерфейсы, такие как NFC, вспомогательные источники питания и др.

Java. Экспресс-курс: Операторы сравнения

Статья проплачена кошками - всемирно известными производителями котят.

Если статья вам понравилась, то можете поддержать проект.

Операторы сравнения выдают логический результат (boolean). Если условие проверки истинно, оператор выдает true, а если ложно - false. К операторам сравнения относятся < (меньше чем), > (больше чем), <= (меньше чем или равно), >= (больше чем или равно), == (равно), != (не равно). Операторы "Равно" и "не равно" можно использовать для всех примитивных типов данных, однако остальные сравнения нельзя использовать к типу boolean.

ОператорПример использованияВозвращает значение "истинно", если...
>a > bа больше b
>=a >= bа больше или равно b
<a < bа меньше b
<=a <= bа меньше или равно b
==a == bа равно b
!=a != bа не равно b
&&a && bа и b истинны, b оценивается условно (если а ложно, b не вычисляется)
||a || bа или b истинно, b оценивается условно (если а истинно, b не вычисляется)
!!aа ложно
&a & bа и b истинны, b оценивается в любом случае
|a | bа или b истинно, b оценивается в любом случае
^a ^ bа и b различны

Наиболее часто операции сравнения используют в выражениях, которые управляют оператором if и операторами цикла.

Обратите внимание, что равенство обозначается двумя знаками равно (==), одиночный знак равно (=) - это оператор присваивания. Типичная ошибка начинающих программистов.

Корректный вариант примера:


int x = 5;
int y = 7;
boolean z = a < b; // результат сохраняется в переменной типа boolean

Примеры для оператора if для Java (В C++ используется другой синтаксис!):


int cat_age;
if(cat_age == 4) // нельзя if(cat_age) - нет сравнения
if(cat_age != 9) // нельзя if(!cat_age) - нет сравнения

Помните, что в Java значения true и false не являются числовыми значениями, как в C++, поэтому, чтобы сравнить значение с другим значением, необходимо явно использовать операторы сравнения.

Реклама

Обучающий набор по Arduino (Piranha) «Стартовый» 16 уроков

Общие сведения

Обучающий набор на базе Arduino — предназначен как для начинающих радиолюбителей, так и для опытных гуру.

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

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

Данный набор выпускается в трех вариациях:

Видео

Подробнее о наборе

Это вторая версия "Обучающий набор по Arduino", единственное отличие которого от первой версии заключается в использовании Piranha UNO - производимого нами полного аналога Arduino UNO. Эта разница так же отображена в названии самого набора.

В уроках Вы узнаете

  • Как считывать и выводить сигналы.
  • Чем отличаются цифровые сигналы от аналоговых, что такое ШИМ.
  • Как работать со светодиодами и излучателями звуков.
  • Как получать данные от датчиков: света, вибраций, наклона.
  • Как работают биполярные транзисторы, и что с их помощью можно сделать.
  • Что такое библиотеки как их устанавливать, подключать и как с ними работать.

В проектах Вы реализуете

  • Имитация горящей свечи.
  • Пианино без клавиш
  • Игра «Simon» (Саймон)

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

Комплектация

Брошюра

Брошюра предназначена для начинающих радиолюбителей-программистов.

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

Брошюра содержит 20 уроков, которые следуют по нарастанию сложности схем и скетчей, и заканчивается 5 проектами, которые можно использовать как готовые устройства. Дання комплектация позволит выполнить 13 уроков и 3 проекта.

Шпаргалка

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

  • Операторы: циклов, условные, прерывающие, логические, арифметические, битовые, сравнения, составные.
  • Данные: типы, переменные, константы, массивы, объекты, структуры, указатели, ссылки, префиксы, спецификаторы, модификаторы.
  • Функции: ввода/вывода, математические, тригонометрические, округления, сравнения, преобразования, работы с: прерываниями, временем, портами, битами, байтами, строками и массивами.

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

Полный перечень

  • 1х Обучающая брошюра содержащая 20 уроков и 5 проектов
  • 1х Шпаргалка
  • 1х Piranha UNO
  • 1х USB Провод
  • 1х Макетная плата
  • 1х Датчик вибрации SW-420
  • 1х Датчик наклона SW-200D
  • 15х Светодиоды (красный x 5 шт., желтый x 5 шт., зеленый x 5 шт.)
  • 3х Светодиод зеленый яркий
  • 1х Светодиод RGB
  • 5х Транзистор биполярный (p-n-p) BC327
  • 5х Транзистор биполярный (n-p-n) BC337
  • 10х Резистор 470 Ом
  • 10х Резистор 1 кОм
  • 10х Резистор 10 кОм
  • 1х Потенциометр 10 кОм
  • 5х Фоторезистор
  • 5х Тактовая кнопка
  • 1х Зуммер
  • 1х Комплект проводов

Arduino IDE: оператор сравнения или отношения

Введение

Оператор отношения - это оператор, который проверяет связь между двумя объектами. Результатом реляционного оператора является либо истина, либо ложь.

В программировании истина представлена ​​ ‘1’ , а ложь представлена ​​ ‘0’ .

В Arduino IDE 6 операторов отношения:

Операторы отношения Обозначение оператора Пример
Более > текущий Год> 2015
Менее 2015
Больше или равно > = текущий год> = 2017
Меньше или равно 2017
Равно == век Год == 2000
Не равно ! = век Год! = 1999

Больше (>)

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

Результат операции будет:

7 больше, чем 4: 1

7 больше 10: 0

Менее (

<)

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

Результат операции:

7 меньше 4: 0

7 меньше 10: 1

Больше или равно (> =)

Возвращает истину, если первое число больше или равно второму числу.Если первое число меньше второго, это приводит к ложному результату. Ниже приведен пример:

Результат операции:

7 больше или равно 10: 0

7 больше или равно 7: 1

Меньше или равно (<=)

Возвращает истину, если первое число меньше или равно второму числу. Если первое число больше второго, это приводит к ложному результату.Ниже приведен пример:

Результат операции:

7 меньше или равно 4: 0

7 меньше или равно 7: 1

Равно (==)

Это приводит к истинному только , если первое число равно второму числу; в противном случае это приведет к ложному результату. Ниже приведен пример:

Результат операции:

7 равно 10: 0

7 равно 7: 1

Не равно (! =)

Возвращает истину, если первое число не равно второму числу; в противном случае это приведет к ложному результату.Ниже приведен пример:

Результат операции:

7 не равно 10: 1

7 не равно 7: 1

Общие сведения об операторах Arduino - Платформа Arduino

Оператор - это символ, который сообщает компилятору выполнять определенные математические или логические функции. Язык кодирования, используемый Arduino, богат встроенными операторами и предоставляет следующие типы операторов

Арифметические операторы
Имя оператора Обозначение оператора Описание
оператор присваивания = Сохраняет значение справа от знака равенства в переменной слева от знака равенства.
вычитание - Вычитает второй операнд из первого
сложение + Добавляет два операнда
Devision / Разделим числитель на знаменатель
Умножитель * Умножение обоих операндов
Код арифметического оператора
 интервал x = 5
int y = 4
int z = 0

х + у = 9
z = x + y // переменная z теперь будет содержать число 9

х - у = 3 
Операторы сравнения
Имя оператора Обозначение оператора Описание
равно == Проверяет, равны ли значения двух операндов или нет, если да, то условие становится истинным.
больше или равно > = Проверяет, больше ли значение левого операнда или равно значению правого операнда, если да, то условие становится истинным.
больше > Проверяет, больше ли значение левого операнда, чем значение правого операнда, если да, то условие становится истинным.
меньше или равно Проверяет, меньше ли значение левого операнда или равно значению правого операнда, если да, то условие становится истинным.
меньше Проверяет, меньше ли значение левого операнда, чем значение правого операнда, если да, то условие становится истинным.
не равно ! = Проверяет, равны ли значения двух операндов или нет, если значения не равны, условие становится истинным.
Операторы сравнения
 интервал x = 5
int y = 4
int z = 0

х == у; // это вернет значение False
х! = у; // это вернет значение True 
Операторы соединения
Имя оператора Обозначение оператора Описание
приращение ++ Оператор приращения, увеличивает целое значение на единицу
уменьшение - Оператор уменьшения, уменьшает целое значение на единицу
сложное сложение + = Добавить оператор присваивания AND.Он добавляет правый операнд к левому операнду и присваивает результат левому операнду
составное вычитание - = Оператор вычитания И присваивания. Он вычитает правый операнд из левого операнда и присваивает результат левому операнду
составной умножитель * = Оператор умножения И присваивания. Он умножает правый операнд на левый и присваивает результат левому операнду
составной делитель / = Оператор деления И присваивания.Он делит левый операнд на правый и присваивает результат левому операнду
Побитовые операторы
Имя оператора Обозначение оператора Описание
и и Двоичный оператор AND копирует бит в результат, если он существует в обоих операндах.
или | Оператор двоичного ИЛИ копирует бит, если он существует в любом из операндов
xor ^ Двоичный оператор XOR копирует бит, если он установлен в одном операнде, но не в обоих.
не ~ Оператор дополнения двоичных единиц является унарным и имеет эффект «переворачивания» битов.
сдвиг влево Оператор двоичного сдвига влево. Значение левого операнда сдвигается влево на количество битов, указанное правым операндом.
сдвиг вправо >> Двоичный оператор сдвига вправо. Значение левого операнда перемещается вправо на количество битов, указанное правым операндом.
Логические операторы
Имя оператора Обозначение оператора Описание
и && Вызывается логическим оператором AND. Если оба операнда не равны нулю, тогда условие становится истинным.
или || Вызывается логическим оператором ИЛИ. Если любой из двух операндов не равен нулю, тогда условие становится истинным.
не ! Вызывается оператором логического НЕ. Используется для изменения логического состояния операнда на обратное. Если условие истинно, то оператор логического НЕ сделает ложным.

Как эффективно использовать оператор Not equal to в Arduino

автор Раду Тырсина

Генеральный директор и основатель

Раду Тырсина был поклонником Windows с тех пор, как получил свой первый компьютер, Pentium III (монстр в то время).Для большинства детей его возраста Интернет был ... Подробнее
  • Arduino основана на языке программирования C / C ++; доступно большинство функций C ++, а также некоторые специальные расширения.
  • Оператор отношения , не равный , является одним из общих элементов структуры языка в Arduino, и мы увидим, как он используется.
  • Для получения более конкретных статей обязательно посетите наш специализированный концентратор Arduino.
  • Кроме того, перейдите в раздел «Инструменты разработчика» для получения более подробной информации.
Чтобы исправить различные проблемы с ПК, мы рекомендуем DriverFix:
Это программное обеспечение будет поддерживать ваши драйверы в рабочем состоянии, тем самым защищая вас от распространенных компьютерных ошибок и сбоев оборудования. Проверьте все свои драйверы сейчас за 3 простых шага:
  1. Загрузите DriverFix (проверенный файл загрузки).
  2. Нажмите Начать сканирование , чтобы найти все проблемные драйверы.
  3. Нажмите Обновить драйверы , чтобы получить новые версии и избежать сбоев в работе системы.
  • DriverFix загрузили 0 читателей в этом месяце.

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

Структура , не равная a, является частью операторов сравнения, наряду с равным , меньше , меньше или равно , больше , больше или равно. Графический знак - ! = .


Как мне использовать

, отличное от , с Arduino?

Не равно - это элемент, сравнивающий одну переменную слева со значением или переменной справа от оператора.

Возвращает истину, если два операнда не равны.

Обычно используется следующий синтаксис:

х! = У; // ложно, если x равно y, и истинно, если x не равно y

То, что не равно , означает, что , если текущее состояние не совпадает с предыдущим состоянием, сделайте это .

В приведенном выше примере вы вызываете , чтобы все значений x, которые не равны 2 , были напечатаны в Serial Monitor с задержкой 500 мс, чтобы вы могли нажать кнопку.

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


Serial Monitor не работает на вашем Arduino? Попробуйте эти решения.


Обратите внимание, что IDE Arduino использует C ++, но поскольку физическая среда ограничена, не все функции C / C ++ могут использоваться и среда Arduino. В результате у Arduino есть вспомогательные функции (специальные расширения), позволяющие легко использовать оборудование.


Часто задаваемые вопросы

Была ли эта страница полезной?

Спасибо!

Недостаточно подробностей Сложно понять Другой Связаться с экспертом

Начать разговор

Arduino IDE: арифметические и логические операторы # 3

Просмотры сообщений: 916

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

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

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

Операторы могут быть трех типов: арифметические, отношения и логические.

Арифметические операторы:

  • + для добавления
  • - на вычитание
  • * для умножения
  • / для подразделения
  • % для вычисления остатка от деления целых чисел

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

Примеры:

int a = 4; int b = 6; int c; с = а + Ь; // c будет равно 10 с = а * б; // c будет равно 24 с = а-б; // c будет равно -2;

int a = 4;

int b = 6;

внутр c;

c = a + b;

// c будет равно 10

c = a * b;

// c будет равно 24

c = a-b;

// c будет равно -2;

Операторы отношения (или сравнения) используются для сравнения содержимого двух переменных и обозначаются символами:

  • == равно (сравнение двух переменных)
  • <менее
  • <= меньше или равно
  • > больше
  • > = больше или равно
  • ! = разные

Операторы отношения (или сравнения) используются в условных и итеративных операторах (if, while, do… while и т. Д.). Если условие проверено, оно возвращает истину, в противном случае - ложь. Операторы отношения (или сравнения) обычно нуждаются в двух аргументах и ​​располагаются между ними.

Итак, мы могли написать:

a = 5 // присвоение (a == 5) // сравнение

a = 5 // присвоение

(a == 5) // сравнение

В первом случае я присваиваю a значение 5, а во втором случае я сравниваю a с 5, и он возвращает логическое значение true, если a равно 5, в противном случае возвращает false.

Итак, давайте приведем несколько примеров:

  • (a> b) - возвращает true, если условие a больше, чем b, в противном случае false
  • (a> = b) - возвращает истину, если условие a больше или равно b, выполняется, ложь в противном случае
  • (a
  • (a <= b) - возвращает true, если условие a меньше или равно b, и false в противном случае
  • (a == b) - возвращает истину, если выполнено условие a, равное b, иначе ложь
  • (a! = B) - возвращает истину, если проверено условие a, отличное от b, иначе ложь

Так, например, если a = 5 и b = 7, тогда выражения будут истинными: (a

Если, например, a = 7 и b = 7, истинными будут выражения: (a <= b), (a> = b) и (a == b).

Логические операторы:

  • && указывает операцию соединения (и)
  • || указывает на операцию дизъюнкции (или)
  • ! указывает отрицание (не)

Как работают эти логические связки?

, И : если оба оператора верны, то результат верен; во всех остальных случаях результат равен

A B A и B
В В В
В F F
F V F
F F F

ИЛИ : Если хотя бы один из операндов равен истине, на выходе будет истина; в противном случае, если ни один из операндов не равен истине, вывод будет ложным.

НЕ : Если входной операнд - истина, то выход будет ложным. Если, с другой стороны, входной операнд ложный, тогда выход будет равен истине. Другими словами, оператор НЕ принимает входные данные и возвращает прямо противоположное.

Использование операторов является основополагающим при составлении кода и решении проблемы.

Предыдущие статьи:

Следите за нами, чтобы быть в курсе новостей!

Симоне Кандидо

Симоне Кандидо является обладателем мондо-технологий в полной мере.Simone ama immedesimarsi in nuove esperienze, la sua filosofia si basa sulla irfrenabile voglia di ampiare a 360 ° le sue conoscenze abbracciando tutti i campi del sapere, in quanto ritiene che il sapere umano sia il connubio perfetmanistic.

операторов в программировании Arduino

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

Это:

  • Арифметические операторы
  • Операторы сравнения
  • Логические операторы
  • Побитовые операторы
  • Составные операторы
Арифметические операторы:

В Arduino есть шесть различных типов арифметических операторов. Их:

  • Операторы присваивания: Операторы присваивания используются для сохранения значения справа от оператора в значение слева от оператора.Например, в коде значение1 = значение2; значение2 будет скопировано в значение1. Оператор обозначается знаком равенства ( = ).
  • Оператор сложения: Оператор сложения используется для dd любых двух операндов. Этот оператор обозначен знаком плюс ( + ). Например, в коде значение1 + значение2 оба значения складываются.
  • Оператор вычитания: Оператор вычитания используется для вычитания одного значения из другого.Этот оператор обозначается знаком минус ( - ). Значение правой части вычитается из значения левой части. Например, в коде значение1-значение2 значение значение2 вычитается из значения значение1 .
  • Оператор умножения: Оператор умножения используется для умножения двух операндов. Обозначается этот оператор знаком умножения ( * ). Например, в коде значение1 * значение2 оба значения будут умножены.
  • Оператор деления: Деление Opetaror используется для деления первого значения на второе. Этот оператор обозначается знаком деления (/). Например, в коде значение1 / значение2 разделит значение значение1 на значение2 .
  • Оператор по модулю: Оператор по модулю используется для нахождения остатка после выполнения деления между любыми двумя операндами. Например, value1 равно 10, а value2 равно 4. Теперь, если мы выполним value1% modulo2 , то результат будет 2.Это потому, что, когда 4 делит 10, остаток равен 2.
Операторы сравнения:

В Arduino есть шесть различных типов операторов сравнения. Их:

  • равно: Этот оператор проверяет, равны ли значения двух операндов. Этот оператор обозначен знаком равенства ( == ).
  • not equal to: Этот оператор проверяет, не равны ли значения двух операндов. Этот оператор обозначается как не равно (! = ).
  • меньше чем: Этот оператор проверяет, меньше ли одно значение другого. Этот оператор обозначается знаком «меньше» ( <).
  • больше чем: Этот оператор проверяет, больше ли одно значение другого. Этот оператор обозначается знаком «больше» (> ).
  • меньше или равно: Этот оператор проверяет, меньше или равно ли значение другому значению. Этот оператор обозначается знаком «меньше или равно» ( <= ).
  • больше или равно: Этот оператор проверяет, является ли значение меньше или равно другому значению. Этот оператор обозначается знаком больше или равно (> = ).
Логические операторы:

В Arduino есть три различных типа логических операторов. Их:

  • и: Этот оператор называется логическим И и возвращает истину, если оба данных условия удовлетворены. Этот оператор обозначается And Sign ( && ).
  • или: Этот оператор называется логическим ИЛИ, он возвращает истину, если выполняется одно из двух заданных условий. Этот оператор обозначается OR ( || )
  • not: Этот оператор называется логическим НЕ и используется для проверки обратного условия. Этот оператор обозначается НЕ (! ).
Побитовые операторы:
Операторы соединения:

arduino - Использование операторов сравнения в директивах препроцессора C ++

и имеют более низкий приоритет, чем ! = .Итак:

  РЕЖИМ & 2! = 0
  

совпадает с

  РЕЖИМ & (2! = 0)
  

2! = 0 логически верно, поэтому результатом оператора ! = будет 1 . Таким образом, это то же самое, что и

.
  РЕЖИМ И 1
  

Это просто проверка первого бита. Пока хочешь:

  (РЕЖИМ & 2)! = 0
  

Чтобы проверить, установлен ли второй бит. Но на самом деле просто удалите часть ! = и выполните:

  #if РЕЖИМ & 2
  

Не забудьте предпочесть имена макросов в верхнем регистре.

Это может звучать и выглядеть странно

Нет, это звучит совершенно нормально. Я бы выбрал гораздо более информативные имена, чем простые и 2 - магические числа сбивают с толку. Нравится:

  #define MODE (MODE_ENABLE_FUNC_1 | MODE_ENABLE_FUNC_2)

#define MODE_ENABLE_FUNC_1 (1 << 0)
#define MODE_ENABLE_FUNC_2 (1 << 1)
#define MODE_ENABLE_FUNC_3 (1 << 2)
#define MODE_IS_ENABLED (режим, функция) (((режим) & (функция))! = 0)
#if MODE_IS_ENABLED (MODE, MODE_ENABLE_FUNC_1)
// так далее. 

Если возможно, предпочитайте использовать шаблоны C ++ и SFINAE, а не простые макросы C.

Что я делаю не так?

Вы предполагаете, что ! = имеет более низкий приоритет, чем и .

Я пытаюсь сделать глупый или невозможный поступок?


Я помню часть Разработка языка C Деннисом М. Ритчи и из названия раздела Neonatal C он пишет:

[...] При преобразовании из B в C нужно заменить & на && в таком операторе; Чтобы сделать преобразование менее болезненным, мы решили оставить приоритет оператора & таким же, как и ==, и просто немного отделить приоритет оператора && от &. Сегодня кажется, что было бы предпочтительнее переместить относительный приоритет & и ==, и тем самым упростить общий C идиома: чтобы проверить замаскированное значение по сравнению с другим значением, нужно написать

  если ((a & маска) == b)...
  

, где внутренние круглые скобки необходимы, но их легко забыть.

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

Tweaking4All.com - Программирование Arduino для начинающих

Обзор этой главы

Полный обзор этого курса можно найти здесь: Обзор курса .

Принятие решений в вашем коде

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

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

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

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

Обнаружена блокировка рекламы

Пожалуйста, отключите блокировку рекламы на нашем веб-сайте.
Мы полагаемся на эти объявления, чтобы иметь возможность запускать наш веб-сайт.
Вы, конечно, можете поддержать нас и другими способами (см. Раздел «Поддержка нас» слева).

Если… то…

Наиболее распространенный способ принятия решения в вашем коде - это, вероятно, так называемое «если… то…», которое они называют «условными операторами». Код, который будет выполняться только при соблюдении определенных условий.

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

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

, если DarkOutside, то SwitchLightsOn

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

, если MoneyInWallet = 0, то GoToTheATM

Я уверен, вы уловили, когда и «если… то…» могут быть полезны в нашей программе.Ваша программа должна реагировать на то, что может измениться, а может и не измениться, или вы хотите, чтобы ваша программа подходила более чем для одного сценария. Это «что-то» может быть значением переменной, или, например, датчиком, обнаруживающим изменение, или устанавливаемым переключателем.

Правильный синтаксис (способ записи):

 

1
2
3
4
5
6

if (condition) {
// делаем то, что необходимо, если условие выполняется
}
else {
// do this is the condition не соблюдается
}

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

Оператор else в выражении «если… то…» всегда помещается в конец , как последнее «условие». По сути, он говорит: «Если ничего не получится, сделайте это»…

Необязательный (строки 4, 5 и 6) «else» позволяет нам определить, что делать, если условие не выполнено. Здесь снова за «else» следует аналогичный блок кода. Эти строки являются необязательными, поэтому, если вы хотите, чтобы ваша программа действовала только при выполнении условия, тогда строки 4, 5 и 6 можно опустить, поэтому мы получим что-то вроде этого:

 

1
2
3

if (условие) {
// делаем то, что необходимо, если условие выполняется
}

« условие » обычно использует оператор сравнения, который приводит либо к истинно , либо к ложному , посмотрите назад в предыдущей главе, если вы забыли, но я резюмирую операторы сравнения здесь еще раз;

Операторы сравнения
Символ Назначение
== равно
! = равно , а не равно
< менее
> больше
<= меньше или равно
> = больше или равно

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

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

 

1
2
3

if (true) {
// делаем то, что необходимо, если условие выполняется
}

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

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

 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

24
25
26
27
28
29
30
31
32
33
34
35

пустая настройка () {
// устанавливаем скорость для последовательного монитора:
Серийный.begin (9600);

// определяем наши переменные
int PocketMoney;
int Экономия;
int AllMyMoney;

// присваиваем значения
PocketMoney = 4;
Экономия = 12;
AllMyMoney = PocketMoney + Сбережения;

// выводим значения на серийный монитор
Serial.print ("PocketMoney =");
Serial.println (PocketMoney);

Serial.print ("Экономия =");
Serial.println (Экономия);

Serial.print ("AllMyMoney =");
Серийный.println (AllMyMoney);

if (AllMyMoney <5) {
Serial.println («Ой ой, у нас мало наличных !!»);
}
else {
Serial.println ("Все хорошо ... не беспокойтесь.");
}
}

void loop () {
// пока оставим пустым
}

Веселье начинается в строке 25, где мы проверяем, что значение переменной «AllMyMoney» меньше (<) 5. Если условие выполнено, отобразится сообщение « Ой ой… у нас мало денег. наличные!! “.Если условие НЕ выполнено, появится сообщение « Все хорошо… не беспокойтесь. “.

Скопируйте и вставьте код в IDE Arduino, скомпилируйте и загрузите его в Arduino. Поскольку условие в строке 25 не выполняется, ваш Arduino проигнорирует блок кода «if» и выполнит блок кода «else», и ответ будет:

PocketMoney = 4
Сбережения = 12
AllMyMoney = 16
Все хорошо ... не беспокойтесь.

Не меняйте код в строке 12, установите наши сбережения на ноль, скомпилируйте и снова загрузите на ваш Arduino: Savings = 0;

Теперь выполняется условие в строке 25, что означает, что кодовый блок «if» будет выполнен, а кодовый блок «else» будет проигнорирован.Наш результат будет выглядеть так:

PocketMoney = 4
Сбережения = 0
AllMyMoney = 4
Ой ой ... у нас мало наличных !!

Если вы хотите опустить часть «else» и видеть предупреждение только тогда, когда у нас мало средств, ваш код будет выглядеть так:

 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

24
25
26
27
28
29
30
31
32

пустая установка () {
// устанавливаем скорость для последовательного монитора:
Серийный.begin (9600);

// определяем наши переменные
int PocketMoney;
int Экономия;
int AllMyMoney;

// присваиваем значения
PocketMoney = 4;
Экономия = 12;
AllMyMoney = PocketMoney + Сбережения;

// выводим значения на серийный монитор
Serial.print ("PocketMoney =");
Serial.println (PocketMoney);

Serial.print ("Экономия =");
Serial.println (Экономия);

Serial.print ("AllMyMoney =");
Серийный.println (AllMyMoney);

if (AllMyMoney <5) {
Serial.println («Ой ой, у нас мало наличных !!»);
}
}

void loop () {
// пока оставим пустым
}

Выражение «если… то…», однако, может быть дополнено любым количеством «если… то…».

Подумайте о следующем примере:

, если AllMyMoney = 0, то паникуйте, иначе, если AllMyMoney <5, получите больше денег, иначе оставайтесь спокойными.

При штабелировании «если.. тогда… иначе, если… тогда… иначе, если… тогда », как это, ваш Arduino будет выполнять условия по одному. Как только он найдет подходящее условие, он выполнит блок кода, который соответствует этому условию, и ВЫЙТИ из всего стека «если… то…».

Операторы «если… то…» могут быть построены с использованием нескольких конструкций «если… то…».
Как только одно из условий выполнено, вся конструкция будет считаться «выполненной и обработанной»… после «если… то…» (в той же конструкции) будет проигнорировано.

Пример:

 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

24
25
26
27
28
29
30
31
32
33
34
35
36
37
38

пустая установка () {
// устанавливаем скорость для последовательного монитора:
Серийный.begin (9600);

// определяем наши переменные
int PocketMoney;
int Экономия;
int AllMyMoney;

// присваиваем значения
PocketMoney = 4;
Экономия = 12;
AllMyMoney = PocketMoney + Сбережения;

// выводим значения на серийный монитор
Serial.print ("PocketMoney =");
Serial.println (PocketMoney);

Serial.print ("Экономия =");
Serial.println (Экономия);

Serial.print ("AllMyMoney =");
Серийный.println (AllMyMoney);

if (AllMyMoney == 0) {
Serial.println ("ПАНИКА !!");
} else if (AllMyMoney <5) {
Serial.println ("Ой, у нас мало наличных !!");
} else if (AllMyMoney> 10) {
Serial.println («Ух, мы богаты !!»);
} else {
Serial.println ("Все хорошо ... не беспокойтесь.");
}
}

void loop () {
// пока оставим пустым
}

Этот код будет:
- напечатать «ПАНИКА !!» если AllMyMoney = 0, или
- выведите «Ой ой, у нас мало наличных !!» когда AllMyMoney меньше 5, или
- «Ух, мы богаты !!» когда AllMoney больше 10, или
- во всех остальных ситуациях напечатайте «Все хорошо ... не беспокойтесь.».

Прохождение нескольких «если… то… иначе, если…»

В этом коде нужно обратить внимание на несколько моментов - и вы должны обратить на это внимание, , чтобы понять, почему определенные вещи работают так, как они работают!

Конструкция « if… then ..» будет завершена после выполнения условия .

Все следующие условия БУДУТ ПРОИГНОРИРОВАТЬ !!!!

В этом примере AllMyMoney = 16, поэтому первые 2 условия НЕ УДАЛЯЮТСЯ.
Третье условие, однако, ВЫПОЛНЯЕТСЯ, так что «Уууу - мы богаты !!» сообщение будет отображаться.
Поскольку рабочее состояние было обнаружено, последнее «else» будет проигнорировано.
Имеет смысл, правда?

Хорошо, теперь давайте изменим строки 11 и 12 на:

 

11
12

PocketMoney = 0;
Экономия = 0;

Таким образом, AllMyMoney обнуляется (0).

При просмотре операторов «если… то…» мы заметим кое-что интересное, которое вызывает множество ошибок в программах.

Итак, AllMyMoney = 0.
Это означает, что первое условие УСПЕШНО и сообщение «ПАНИКА !!» будет отображаться.
Однако условие 2 (AllMyMoney меньше 5) также выполняется, но… оно не будет выполнено.

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

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

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

Итак, что нам нужно сделать, чтобы оба условия запускали сообщение?
Что ж, по сути, нам нужно разобрать сложную конструкцию «если… то…» и сделать из нее отдельные конструкции, что обычно приводит к осложнениям, когда вы используете в конце «else».

Я написал небольшой пример, который разделяет нашу сложную конструкцию «если… то…», например:

 

25
26
27
28
29
30
31
32
33
34
35

если (AllMyMoney == 0) {
Serial.println («ПАНИКА !!»);
}

if (AllMyMoney <5) {
Serial.println («Ой, у нас мало наличных !!»);
}

if (AllMyMoney> 10) {
Последовательный.println («Уууу - мы богаты !!»);
}

В основном мы делали индивидуальные конструкции «если… то…». Видите ли: нигде не упоминается «другое».
Однако отсутствие «else» создает небольшую проблему.

В нашей исходной программе мы сказали:

Если AllMyMoney == 0, то «Паника», , иначе , если AllMyMoney <5, то «Ой, ох», , иначе, , если AllMyMoney> 10, то «Вуху», , еще , «не беспокойтесь».

Но в разобранной конструкции «если… то…» мы охватили все , кроме оператора else :

Если AllMyMoney == 0, то «Паника».
Если AllMyMoney <5, тогда «Ой ой».
Если AllMyMoney> 10, то «Woohoo».

Мы не можем добавить «else» ни к одному из этих трех, поскольку оно сработает, даже если в этом нет необходимости. Посмотрите, что произойдет, если мы добавим «else» ко всем этим трем условиям:

Если AllMyMoney == 0, то «Паника», иначе «Не беспокойся».
Если AllMyMoney <5, тогда «Ой» иначе «Не беспокойся».
Если AllMyMoney> 10, то «Ууууу», иначе «Не беспокойся».

Если бы AllMyMoney было бы 8, то мы бы увидели «Не беспокойся» 3 раза, так как все 3 условия не будут выполнены.
Если бы AllMyMoney был бы равен 0, мы бы увидели «Паника» и дважды «Не беспокойся» - что было бы неверно.
Если бы AllMyMoney было бы 4, то мы бы дважды увидели «Не беспокойся» и одно «О, о!» - это тоже было бы неправильно, верно?

Так когда же должна сработать эта «еще» ситуация?

Обнаружена блокировка рекламы

Пожалуйста, отключите блокировку рекламы на нашем веб-сайте.
Мы полагаемся на эти объявления, чтобы иметь возможность запускать наш веб-сайт.
Вы, конечно, можете поддержать нас и другими способами (см. Раздел «Поддержка нас» слева).

Более сложные условия «если… то…»

Если мы посмотрим на наши условия, то увидим «диапазон» для каждого условия, и некоторые из этих «диапазонов» перекрываются.
Итак, 0 и значения меньше 5 охватываются первыми двумя условиями - эти два перекрываются! (0 меньше 5!)
Значения больше 10 также охватываются третьим условием.

Так где же разрыв?

Значения , равные или превышающие (> =) 5 И , меньшие или равные (<=) 10 не покрываются.

Пошагово, считая целые числа:

Условие 1 покрывает «0» (ноль).
Условие 2 распространяется на «0, 1, 2, 3, 4» (менее 5 - исключая 5!).
Условие 3 охватывает «11, 12, 13,… бесконечность» (больше 10 - исключая 10!).

Теперь видите разрыв? Разрыв составляет «5, 6, 7, 8, 9, 10».

Итак, это числа , равные или превышающие (> =) 5 И , меньшие или равные (<=) 10.

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

Логический оператор
Символ Назначение
&& И
|| ИЛИ
! НЕ

Таким образом, пробел соответствует каждому числу, которое больше или равно 5, что в коде выглядит так: AllMyMoney> = 5 .

Но эти числа также ограничены, поскольку они не могут превышать «10», поэтому условие будет следующим: AllMyMoney <= 10 .

Но ОБЕИХ из них должны быть верными для этих чисел в нашем промежутке. Таким образом, нам нужно убедиться, что выполняются ОБЕИХ условий.

Можно использовать один вариант и «если… то…» в «если… то…», например:

 

if (AllMijMoney> = 5) {
if (AllMijMoney <= 10) {
// сделать это
}
}

Но это может очень быстро стать беспорядочным ...

Теперь давайте посмотрим на таблицу логических операторов и послушаем следующее: пробел состоит из значений> = 5 и <= 10.Правильно?

Ключевое слово здесь - « и », поэтому давайте посмотрим на таблицу «и» из предыдущей главы:

И результаты
Состояние1 Состояние2 Результат Conditon1 AND Condition2
истинно правда = правда
правда ложь = ложь
ложный правда = ложь
ложный ложь = ложь

Я то немного переписал, вместо «значение» набрал «условие».

Таким образом, оба условия должны быть истинными , чтобы возник этот разрыв. В коде: AllMyMoney> = 5 && AllMyMoney <= 10 .

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

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

Код в круглых скобках в операторе будет выполнен первым .

Итак, мы пишем это так: (AllMyMoney> = 5) && (AllMyMoney <= 10)

Что во время выполнения определит результат «AllMyMoney> = 5» и «AllMyMoney <= 10» и заменит его результатом этого.Например, скажем, что AllMyMoney = 6, тогда будут выполнены следующие шаги:

Шаг 1: (AllMyMoney> = 5) && (AllMyMoney <= 10) и «AllMyMoney = 6»
Шаг 2: (true) && (AllMyMoney <= 10)
Step 3: (true) && (верно)

, что дает true && true , что (согласно нашей таблице выше) является « true ».

Итак, наш модифицированный код будет:

 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44

пусто {
// устанавливаем скорость для последовательного монитора:
Серийный.begin (9600);

// определяем наши переменные
int PocketMoney;
int Экономия;
int AllMyMoney;

// присваиваем значения
PocketMoney = 0;
Экономия = 4;
AllMyMoney = PocketMoney + Сбережения;

// выводим значения на серийный монитор
Serial.print ("PocketMoney =");
Serial.println (PocketMoney);

Serial.print ("Экономия =");
Serial.println (Экономия);

Serial.print ("AllMyMoney =");
Серийный.println (AllMyMoney);

if (AllMyMoney == 0) {
Serial.println ("ПАНИКА !!");
}

if (AllMyMoney <5) {
Serial.println ("Ой, у нас мало наличных !!");
}

if (AllMyMoney> 10) {
Serial.println («Ух, мы богаты !!»);
}

if ((AllMyMoney> = 5) && (AllMyMoney <= 10)) {
Serial.println («Все хорошо ... не беспокойтесь.»);
}
}

void loop () {
// пока оставим пустым
}

Я настоятельно рекомендую поиграть со значениями в строках 11 и 12, а затем в условиях строки 25.

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

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

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

Рассмотрим пример: (((c1) && (c2)) || ((c3) && (c4)))
Каждое c-число представляет собой условие.

Arduino сначала определит результат самых внутренних скобок ( 1 на чертеже), красных, которые являются условием c1, затем c2, затем c3 и затем c4, и заменит их результатами, которые сделают это : ((o1 && o2) || (o3 && o4))
(где o-число обозначает результат)

Затем он перейдет на один уровень скобок дальше, на зеленые ( 2 на чертеже), что приведет к: (o12 || o34).
(где o12 - результат o1 && o2, а o34 - результат o3 && o4).

Затем, наконец, он выполнит самые внешние скобки ( 3 на чертеже), синие, в результате получится: o1234
(где o1234 - окончательный результат o12 || o34).

Все это, представленное на чертеже, выглядело бы примерно так:

Использование скоб - обработка изнутри наружу

Если это было немного выше вашей головы, не беспокойтесь….давайте посмотрим на пример расчета.

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

А = 3 * 4 + 12/4 + 6 * 3

Если бы мы ничего об этом не думали и не сохраняли бы приоритет над этими вычислениями, то ответ мог бы быть:

A = 12 + 12/4 + 6 * 3
A = 24/4 + 6 * 3
A = 6 + 6 * 3
A = 12 * 3
A = 36

Или надо было сделать так:

A = 12 + 12/4 + 6 * 3
A = 12 + 12/10 * 3
A = 12 + 12/30
A = 24/30
A = 0.8

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

Имейте в виду : при вычислениях, умножении и делении лучше прибегать к сложению и вычитанию!

А = ((3 * 4) + (12/4) + (6 * 3))

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

A = ((12) + (12/4) + (6 * 3))
A = ((12) + (3) + (6 * 3))
A = ((12) + (3) + (18))
A = (15 + 18)
A = 33

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

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

Обнаружена блокировка рекламы

Пожалуйста, отключите блокировку рекламы на нашем веб-сайте.
Мы полагаемся на эти объявления, чтобы иметь возможность запускать наш веб-сайт.
Вы, конечно, можете поддержать нас и другими способами (см. Раздел «Поддержка нас» слева).

Переключатель… корпус…

Конструкция «switch… case…» немного сложнее, но очень практична в ситуациях, когда нам нужно много операторов «if».

Как и операторы if, оператор «switch… case…» управляет потоком программ, что позволяет вам указать конкретный код, который будет выполняться, в зависимости от условий, которые выполняются или нет.Этот оператор работает немного иначе, чем оператор «если».

Оператор «if» позволяет нам определять наши условия с помощью любого из операторов сравнения и использовать логические значения.
Однако оператор «switch» работает только с «равно».

Давайте посмотрим на пример «если», который можно заменить оператором switch.

  () {
// устанавливаем скорость для последовательного монитора:
Серийный.begin (9600);

// определяем нашу переменную
int A = 5;

если (A == 1) {
Serial.println ("A = 1");
}
иначе, если (A == 2) {
Serial.println ("A = 2");
}
иначе, если (A == 3) {
Serial.println («А = 3»);
}
иначе, если (A == 4) {
Serial.println («А = 4»);
}
иначе, если (A == 5) {
Serial.println («А = 5»);
}
иначе, если (A == 6) {
Serial.println («А = 6»);
}
иначе, если (A == 7) {
Серийный.println («А = 7»);
}
иначе, если (A == 8) {
Serial.println («А = 8»);
}
иначе, если (A == 9) {
Serial.println («А = 9»);
}
иначе, если (A == 10) {
Serial.println («А = 10»);
}
еще {
Serial.println («меньше 1 или больше 10»);
}
}

void loop () {
// пока оставим пустым
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
9000id9 установка

Результатом этого кода будет: A = 5

Это много утверждений «если», не так ли?
И да, это можно написать намного эффективнее.Но мы используем его только для того, чтобы проиллюстрировать, как работает « switch ».

Обычный способ использования оператора « switch » выглядит так:

переключатель (переменный) {
case value1:
// что-то делаем, когда переменная равна значению 1
сломать;
case value2:
// что-то делаем, когда переменная равна value2
сломать;

... // и т. Д.

default:
// если ничего не совпадает, сделайте это ... (необязательно)
break;
}

Таким образом, оператор « switch » берет текущее значение «переменной» и сравнивает это значение со значением, указанным в каждом из операторов « case », чтобы увидеть, нужно ли выполнять следующий код.Необязательный оператор « default :» (вы не обязаны его использовать) будет выполнен, если не будет выполнено ни одно из значений «case».

Теперь давайте посмотрим на тот же код, теперь используя оператор « switch »:

 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

24
25

Пустая установка () {
// устанавливаем скорость для последовательного монитора:
Серийный.begin (9600);

// определяем нашу переменную
int A = 5; Переключатель

(A) {
case 1: Serial.println ("A = 1");
, случай 2: Serial.println ("A = 2");
case 3: Serial.println ("A = 3");
, случай 4: Serial.println ("A = 4");
, случай 5: Serial.println ("A = 5");
case 6: Serial.println ("A = 6");
case 7: Serial.println ("A = 7");
, случай 8: Serial.println ("A = 8");
case 9: Serial.println ("A = 9");
case 10: Последовательный.println («А = 10»);
по умолчанию: Serial.println («A меньше 1 или больше 10»);
}
}

void loop () {
// пока оставим пустым
}

Я намеренно допустил ошибку в этом коде, поэтому не воспринимайте это как способ сделать это!

Неожиданный результат:

A = 5
A = 6
A = 7
A = 8
A = 9
A = 10
A меньше 1 или больше 10

Причина этого в том, что оператор « switch » будет искать « case », который равен true , и выполнять весь код после этого.
Таким образом, когда A = 5, все операторы, начиная с «case 5:», будут выполнены.

В некоторых случаях это может быть практичным, но в большинстве случаев мы хотели бы, чтобы это прекратилось после завершения кода для «case 5:». Это делается с помощью оператора « break » после последнего оператора каждого из наблюдений.

Не забывайте оператор «break» с каждым «case», если вы хотите ограничить выполнение кода только одним из операторов «case».

Наш модифицированный код будет выглядеть так:

 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

24
25
26
27
28
29
30
31
32
33
34
35

пустая настройка () {
// устанавливаем скорость для последовательного монитора:
Серийный.begin (9600);

// определяем нашу переменную
int A = 5; Переключатель

(A) {
case 1: Serial.println ("A = 1");
перерыв;
, случай 2: Serial.println ("A = 2");
перерыв;
case 3: Serial.println ("A = 3");
перерыв;
, случай 4: Serial.println ("A = 4");
перерыв;
, случай 5: Serial.println ("A = 5");
перерыв;
case 6: Serial.println ("A = 6");
перерыв;
корпус 7: Последовательный.println («А = 7»);
перерыв;
, случай 8: Serial.println ("A = 8");
перерыв;
case 9: Serial.println ("A = 9");
перерыв;
case 10: Serial.println ("A = 10");
перерыв;
по умолчанию: Serial.println («A меньше 1 или больше 10»);
}
}

void loop () {
// пока оставим пустым
}

Чтобы увидеть, как работает « default », вы можете изменить строку 6 на A = 11; (например), что приведет к тому, что все операторы «case» не будут выполнены, а «switch» выполнит оператор «default».Если бы можно было пропустить утверждение «по умолчанию», и ни один из случаев не был бы обнаружен, то просто ничего не произошло бы.

Использование « по умолчанию » с оператором « переключатель » - необязательно

Оператор switch используется не часто, по крайней мере, не так часто, как оператор if.
Также имейте в виду, что значения case лучше всего размещать в логическом порядке - это делает код более читабельным, и вы не столкнетесь с потенциально неожиданными результатами.

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

Если у вас есть вопросы, просто задавайте их ниже, в разделе комментариев, и имейте в виду: глупых вопросов не бывает! В какой-то момент нам всем пришлось начать!

Следующая глава: Программирование Arduino для начинающих - Часть 5: Циклы

.

Добавить комментарий

Ваш адрес email не будет опубликован. Обязательные поля помечены *