Arduino остаток от деления. Арифметические операции и операторы в Arduino: полное руководство

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

Основные арифметические операторы в Arduino

Arduino поддерживает стандартный набор арифметических операторов, которые позволяют выполнять базовые математические вычисления в скетчах. Основные операторы включают:

• Сложение (+)
• Вычитание (-)
• Умножение (*)
• Деление (/)
• Остаток от деления (%)

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

Оператор сложения в Arduino

Оператор сложения (+) используется для сложения двух чисел. Пример использования:

int a = 5;
int b = 3;
int sum = a + b; // sum будет равно 8

Оператор сложения можно применять как к целым числам, так и к числам с плавающей точкой:

float x = 2.5;
float y = 1.7;
float result = x + y; // result будет равно 4.2
 

Вычитание в скетчах Arduino

Оператор вычитания (-) позволяет вычесть одно число из другого:

int a = 10;
int b = 7;
int difference = a - b; // difference будет равно 3

При вычитании чисел с плавающей точкой результат также будет числом с плавающей точкой:

float x = 5.5;
float y = 2.3;
float result = x - y; // result будет равно 3.2

Умножение чисел в Arduino

Для умножения используется оператор *. Пример умножения целых чисел:

int a = 4;
int b = 3;
int product = a * b; // product будет равно 12

При умножении чисел с плавающей точкой результат также будет числом с плавающей точкой:

float x = 2.5;
float y = 3.0;
float result = x * y; // result будет равно 7.5

Операция деления в Arduino

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

int a = 10;
int b = 3;
int quotient = a / b; // quotient будет равно 3

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

float x = 10.0;
float y = 3.0;
float result = x / y; // result будет равно 3.333...

Вычисление остатка от деления в Arduino

Оператор % позволяет получить остаток от целочисленного деления:

int a = 17;
int b = 5;
int remainder = a % b; // remainder будет равно 2

Оператор % работает только с целыми числами. При использовании с числами с плавающей точкой результат будет округлен.

Приоритет арифметических операций в Arduino

При выполнении сложных арифметических выражений важно учитывать приоритет операций. В Arduino действуют следующие правила приоритета:

1. Операции в скобках выполняются в первую очередь
2. Умножение и деление имеют более высокий приоритет, чем сложение и вычитание
3. Операции с одинаковым приоритетом выполняются слева направо

Пример сложного выражения с учетом приоритета:

int result = 5 + 3 * 2 - (8 / 4);
// Сначала вычисляется: (8 / 4) = 2
// Затем: 3 * 2 = 6
// Потом: 5 + 6 = 11
// И наконец: 11 - 2 = 9
// Итоговый результат: 9

Побитовые операции в Arduino

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

• & (побитовое И)
• | (побитовое ИЛИ)
• ^ (побитовое исключающее ИЛИ)
• ~ (побитовое НЕ)
• << (сдвиг влево)
• >> (сдвиг вправо)

Пример использования побитовой операции для извлечения младших 8 бит из 16-битного числа:

unsigned int value = 1000; // 0000 0011 1110 1000 в двоичном виде
unsigned char lowByte = value & 0xFF; // 0xFF = 1111 1111
// lowByte будет равно 232 (1110 1000 в двоичном виде)

Оптимизация арифметических операций в Arduino

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

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

Пример оптимизации с использованием побитовых операций:

// Неоптимизированный вариант
int result = number / 2;

// Оптимизированный вариант с использованием побитового сдвига
int result = number >> 1;

Работа с большими числами в Arduino

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

• Использование типа данных long long для целых чисел (64 бита)
• Применение библиотек для работы с большими числами, например, BigNumber
• Реализация собственных функций для работы с большими числами

Пример использования типа long long для работы с большими числами:

long long bigNumber = 1000000000000LL; // Суффикс LL указывает на тип long long
long long result = bigNumber * 2;
Serial.println(result); // Выведет 2000000000000

Обработка ошибок при арифметических операциях

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

int a = 32767; // Максимальное значение для int
int b = 1;
long result = (long)a + b; // Используем приведение типов для предотвращения переполнения

if (b != 0) {
  int quotient = a / b;
} else {
  // Обработка деления на ноль
  Serial.println("Error: Division by zero");
}

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

Операции с целыми числами. Программирование на языке Python

Похожие презентации:

Программирование на Python

Моя будущая профессия. Программист

Программирование станков с ЧПУ

Язык программирования «Java»

Базы данных и язык SQL

Основы web-технологий. Технологии создания web-сайтов

Методы обработки экспериментальных данных

Программирование на языке Python (§ 62 — § 68)

Микроконтроллеры. Введение в Arduino

Программирование на языке Python (§ 54 — § 61)

Операции с числами
8 класс. Программирование на языке Python
Арифметические операции с числами
* — умножение
** — возведение в степень
— — вычитание
+ — сложение
/ — деление
// — деление нацело
% — остаток от деления
Примеры арифметических операций
print(5 * 2) #10 — умножение
print(5 ** 2) #25 – возведение в степень
print(5 + 2) #7 — сложение

English     Русский Правила

Урок 3. Переменные и математические операции в MicroPython.

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

Переменные в MicroPython.

MicroPython основан на Python 3, поэтому типы данных и работа с переменными будет точно такой же, как и в Python. Переменная в Python – это имя, которое используется для обозначения ячейки памяти. Переменные также известны как идентификаторы и используются для хранения значений. Более подробно изучить переменные в Python

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

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

Рассмотрим пример из прошлого урока и добавим глобальную переменную delay = 0.5

import machine
import time
led = machine.Pin(2, machine.Pin.OUT)
delay = .5 # глобальная переменная
while True:
    delay = delay + 0.1
    led.value(1)
    time.sleep(delay)
    led.value(0)
    time.sleep(delay)
    srt = "delay = " # локальная переменная
    print(srt)
    print(delay)

Данную переменную можно использовать в любом месте программы. Например, в цикле, прибавляя к ней значение 0,1 и в дальнейшем использовать полученное значение как время задержки между включением и выключением светодиода. Для понимания, что получилось, значение выводим с помощью команды print(delay).

И создадим локальную строковую переменную srt = «delay = «, которую можно использовать только в цикле, где переменная была объявлена. Если попробовать получить значения данной переменой в другом месте, то получим ошибку. Также в консоль выводим значение переменной srt.

Запустим программу и получим в консоли следующую информацию.

Типы данных в Python.

Давайте рассмотрим основные типы данных Python.

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

Ещё одна важная операция, которая используется для объединения строк, называется Конкатенация.

Для того чтобы к строке добавить переменную, нужно использовать символ «+». Если нужно добавить к строке переменную другого типа, её необходимо перевести в строку. Для этого используется функция str(). Данную особенность нужно запомнить. В противном случае при запуске программы вы получите ошибку.

Проверим, что у нас получилось. Как видим, всё выводится.

Математические операции в MicroPython.

Математических операций в Python много, поэтому рассмотрим только основные.

Чтобы сложить, умножить, вычесть число используются операторы, как и в математике: +, -, *. Деление обозначается вот таким символов «/».

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

#Целочисленное деление (//)
print(15//2)

Целочисленное деление обозначается символом «//», и в ответ получаем целое число без учёта остатка от деления.

#Остаток от деления (%)
print(21 % 3)

Чтобы найти остаток от деления, используется оператор «%». Ответом будет остаток от делания числа. Если остатка нет, то ответ будет равен нулю.

#Возведение в степень (**)
a = 2
b = 10
print(a ** b)

И возведение в степень «**». Возведём 2 в 10 степень. Результат будет 1024.

В Python есть и другие математические операции, но их использовать будем редко.

Мигание светодиодом. Оптимизируем код.

Давайте оптимизируем код «мигание светодиодом», используя полученные знания в данном уроке.Создадим две глобальные переменные «x = True» – состояние светодиода и «delay = 0.5» — время задержки между включением и выключением светодиода.

В цикле инвертируем булеву переменную, то есть меняем значения с True на False и наоборот. Для этого используется оператор «not». Так как цикл бесконечный, данное значение будет постоянно меняться. Если переменная равна «True», то она поменяет своё значение на «False» и, если была «False», измениться на «True».

И, чтобы переменную «x» можно было использовать для включения светодиода, её нужно перевести в целочисленное значение. В этом нам поможет функция int(x). В конце цикла выведем значения переменой «x», чтобы отследить работу программы.

При каждом выполнении цикла состояние светодиода меняется. И в консоли видим значение переменной «x» на данный момент.

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

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

Мигание двумя светодиодами на ESP32 и MicroPython.

Давайте подключим два внешних светодиода к ESP32 вот по такой схеме.

Как видно из схемы, светодиоды подключены к 4 и 5 GPIO микроконтроллера.Возьмём предыдущий пример и на его основе реализуем задачу. Управлять будем двумя светодиодами красного и синего цвета, инициализируем pins для работы с ними.

Немного изменим основной цикл программы. Первым делом включим красный светодиод. Затем инвертируем переменную «x» и выключим синий светодиод. Подождём заданное количество времени. Это вся программа.

Почему же светодиоды включаются и выключаются поочерёдно? Всё просто, так как цикл выполняется бесконечное количество раз при повторном выполнении цикла «x = False», что приведёт к выключению красного светодиода. Затем мы инвертируем переменную «x» и тем самым включаем синий светодиод. Ждём заданное время и повторно выполняем цикл. Включаем красный, выключаем синий и так далее, бесконечное количество раз.

Таким образом получилась реализовать простую мигалку на MicroPython и ESP32.

Понравился Урок 3. Переменные и математические операции в MicroPython? Не забудь поделиться с друзьями в соц. сетях.

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

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

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

Фотографии к статье

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

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

	Пример 1. Переменные в MicroPython.py	1 Kb	208	Скачать
	Пример 2. Типы данных в Python..py	1 Kb	210	Скачать
	Пример 3. Математические операции в MicroPython..py	1 Kb	216	Скачать
	Пример 4. Мигание светодиодом. Оптимизируем код. .py	1 Kb	216	Скачать
	Пример 5. Мигание светодиодом оптимальный код.py	0 Kb	214	Скачать
	Пример 6. Мигание двумя светодиодами на ESP32 и MicroPython.py	1 Kb	223	Скачать

Arduino IDE: Арифметические операторы — STEMpedia

 volatile unsigned int Phase[] = {1000, 1000, 1000, 1000}; // определен массив из 2 байтов int
    
unsigned char rem = ((unsigned char *)&(phase[0] ))[1]; // ???
 

 unsigned char rem = 0b0000000011111111 & Phase[0]; // извлечь последние 8 бит. 
 

 volatile unsigned int Phase[] = {1000, 1000, 1000, 1000};
unsigned char* p = (unsigned char*) фаза; // интерпретировать приведение как массив байтов
целое рем = р[1]; // копируем второй байт в другую переменную
 

 фаза[0] равна 0x3e8
   р[0] равно 0xe8
   р[1] равно 0x03
 

 int rem = (unsigned char *)&( фаза[0] )[1]; // ???
 

 беззнаковый символ rem = ((беззнаковый символ*)&фаза[0])[0];