String ()

Класс String, являющийся частью ядра начиная с версии 0019, позволяет использовать строки текста и манипулировать ими более сложными способами, чем массивы символов. Вы можете объединять строки, добавлять к ним, искать и заменять подстроки и многое другое. Это занимает больше памяти, чем простой массив символов, но это также более полезно.

Для справки: символьные массивы называются строками с маленьким ‘s’, а экземпляры класса String называются строками с большой буквы S. Обратите внимание, что константные строки, указанные в «двойных кавычках», обрабатываются как массивы символов, не экземпляры класса String

Charat ()

Доступ к определенному символу строки.

сравнить с()

Сравнивает две строки, проверяя, идет ли одна до или после другой, или равны ли они. Строки сравниваются посимвольно, используя значения символов ASCII. Это означает, например, что «а» предшествует «б», но после «А». Числа идут перед буквами.

CONCAT ()

Добавляет параметр в строку.

c_str ()

Преобразует содержимое строки как строку в стиле C с нулевым символом в конце. Обратите внимание, что это дает прямой доступ к внутреннему буферу String и должно использоваться с осторожностью. В частности, вы никогда не должны изменять строку через возвращаемый указатель. Когда вы изменяете объект String или когда он уничтожается, любой указатель, ранее возвращенный c_str (), становится недействительным и больше не должен использоваться.

EndsWith ()

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

равна ()

Сравнивает две строки на равенство. Сравнение чувствительно к регистру, что означает, что строка «hello» не равна строке «HELLO».

equalsIgnoreCase ()

Сравнивает две строки на равенство. Сравнение не чувствительно к регистру, то есть String («привет») равен String («HELLO»).

GetBytes ()

Копирует символы строки в предоставленный буфер.

индекс()

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

LastIndexOf ()

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

длина ()

Возвращает длину строки в символах. (Обратите внимание, что это не включает завершающий нулевой символ.)

Удалить()

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

заменить ()

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

резерв()

Функция String reserve () позволяет вам выделить буфер в памяти для работы со строками.

setCharAt ()

Устанавливает символ строки. Не влияет на индексы за пределами существующей длины строки.

начинается с()

Проверяет, начинается ли строка с символов другой строки.

toCharArray ()

Копирует символы строки в предоставленный буфер.

подстрока ()

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

toInt ()

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

держаться на плаву()

Преобразует действительную строку в число с плавающей точкой. Входная строка должна начинаться с цифры. Если строка содержит нецифровые символы, функция прекратит выполнение преобразования. Например, строки «123.45», «123» и «123fish» преобразуются в 123.45, 123.00 и 123.00 соответственно. Обратите внимание, что «123,456» приближается к 123,46. Также обратите внимание, что значения с плавающей точкой имеют только 6-7 десятичных цифр и что более длинные строки могут быть обрезаны.

toLowerCase ()

Получить строчную версию String. Начиная с 1.0 toLowerCase () изменяет строку на месте, а не возвращает новую.

toUpperCase ()

Получите версию строки в верхнем регистре. Начиная с 1.0 toUpperCase () изменяет строку на месте, а не возвращает новую.

отделка()

Получите версию String с удаленными начальными и конечными пробелами. Начиная с 1.0, trim () изменяет строку на месте, а не возвращает новую.

В следующем наброске используются некоторые функции строки C.

пример

void setup() {
   char str[] = "This is my string"; // create a string
   char out_str[40]; // output from string functions placed here
   int num; // general purpose integer
   Serial.begin(9600);

   // (1) print the string
   Serial.println(str);

   // (2) get the length of the string (excludes null terminator)
   num = strlen(str);
   Serial.print("String length is: ");
   Serial.println(num);

   // (3) get the length of the array (includes null terminator)
   num = sizeof(str); // sizeof() is not a C string function
   Serial.print("Size of the array: ");
   Serial.println(num);

   // (4) copy a string
   strcpy(out_str, str);
   Serial.println(out_str);

   // (5) add a string to the end of a string (append)
   strcat(out_str, " sketch.");
   Serial.println(out_str);
   num = strlen(out_str);
   Serial.print("String length is: ");
   Serial.println(num);
   num = sizeof(out_str);
   Serial.print("Size of the array out_str[]: ");
   Serial.println(num);
}

void loop() {

}

Результат

This is my string
String length is: 17
Size of the array: 18
This is my string
This is my string sketch.
String length is: 25
Size of the array out_str[]: 40

Эскиз работает следующим образом.

Распечатать строку

Вновь созданная строка печатается в окне Serial Monitor, как было сделано в предыдущих эскизах.

Получить длину строки

Функция strlen () используется для получения длины строки. Длина строки указана только для печатных символов и не содержит нулевого терминатора.

Строка содержит 17 символов, поэтому мы видим 17 напечатанных в окне Serial Monitor.

Получить длину массива

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

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

Копировать строку

Функция strcpy () используется для копирования строки str [] в массив out_num []. Функция strcpy () копирует вторую строку, переданную ей, в первую строку. Копия строки теперь существует в массиве out_num [], но занимает всего 18 элементов массива, поэтому у нас по-прежнему есть 22 свободных элемента char в массиве. Эти свободные элементы находятся после строки в памяти.

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

Добавить строку к строке (объединить)

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

После объединения длина строки печатается, чтобы показать длину новой строки. Длина массива затем печатается, чтобы показать, что у нас есть строка длиной 25 символов в массиве длиной 40 элементов.

Помните, что строка длиной 25 символов на самом деле занимает 26 символов массива из-за нулевого завершающего нуля.

Границы массива

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

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

Arduino — струнный объект

Второй тип строки, используемый в программировании Arduino, — это String Object.

Что такое объект?

Объект — это конструкция, которая содержит как данные, так и функции. Объект String может быть создан как переменная и ему может быть присвоено значение или строка. Объект String содержит функции (которые в объектно-ориентированном программировании (ООП) называются «методами»), которые работают с строковыми данными, содержащимися в объекте String.

Следующий эскиз и объяснение прояснят, что такое объект и как используется объект String.

пример

void setup() { 
   String my_str = "This is my string.";
   Serial.begin(9600);

   // (1) print the string
   Serial.println(my_str);

   // (2) change the string to upper-case
   my_str.toUpperCase();
   Serial.println(my_str);

   // (3) overwrite the string
   my_str = "My new string.";
   Serial.println(my_str);

   // (4) replace a word in the string
   my_str.replace("string", "Arduino sketch");
   Serial.println(my_str);

   // (5) get the length of the string
   Serial.print("String length is: ");
   Serial.println(my_str.length());
}

void loop() { 

}

Результат

This is my string.
THIS IS MY STRING.
My new string.
My new Arduino sketch.
String length is: 22

Строковый объект создается и ему присваивается значение (или строка) в верхней части эскиза.

String my_str = "This is my string." ;

Это создает объект String с именем my_str и присваивает ему значение «Это моя строка».

Это можно сравнить с созданием переменной и присвоением ей значения, такого как целое число —

int my_var = 102;

Эскиз работает следующим образом.

Печать строки

Строка может быть напечатана в окне Serial Monitor точно так же, как строка массива символов.

Преобразовать строку в верхний регистр

Строковый объект my_str, который был создан, имеет ряд функций или методов, с которыми можно работать. Эти методы вызываются с использованием имени объекта, за которым следует оператор точки (.), А затем имя используемой функции.

my_str.toUpperCase();

Функция toUpperCase () работает со строкой, содержащейся в объекте my_str, которая имеет тип String, и преобразует строковые данные (или текст), которые содержит объект, в символы верхнего регистра. Список функций, содержащихся в классе String, можно найти в справочнике Arduino String. Технически String называется классом и используется для создания объектов String.

Перезаписать строку

Оператор присваивания используется для назначения новой строки объекту my_str, который заменяет старую строку

my_str = "My new string." ;

Оператор присваивания нельзя использовать со строками символьных массивов, но он работает только с объектами String.

Замена слова в строке

Функция replace () используется для замены первой передаваемой ей строки второй передаваемой ей строкой. replace () — это еще одна функция, встроенная в класс String и доступная для использования в объекте String my_str.

Получение длины строки

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

Когда использовать строковый объект

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

Основным недостатком использования объекта String является то, что он использует много памяти и может быстро израсходовать оперативную память Arduinos, что может привести к зависанию, аварийному завершению работы или непредвиденному поведению Arduino. Если эскиз на Arduino маленький и ограничивает использование объектов, то проблем быть не должно.

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

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

Где используются строки

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

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

Ардуино — Время

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

функция задержки ()

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

Функция delayMicroseconds ()

Функция delayMicroseconds () принимает один целочисленный (или числовой) аргумент. Есть тысяча микросекунд в миллисекунде и миллион микросекунд в секунду.

функция миллис ()

Эта функция используется для возврата количества миллисекунд в тот момент, когда плата Arduino запускает текущую программу.

функция micros ()

Функция micros () возвращает количество микросекунд с момента, когда плата Arduino запускает текущую программу. Это число переполняется, то есть возвращается к нулю примерно через 70 минут.

Arduino — Массивы

Массив — это последовательная группа ячеек памяти одного типа. Чтобы сослаться на конкретное местоположение или элемент в массиве, мы указываем имя массива и номер позиции конкретного элемента в массиве.

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

Таким образом, элементами массива C являются C [0] (произносится как «C sub zero»), C [1], C [2] и так далее. Максимальный индекс в массиве C равен 10, что на 1 меньше, чем количество элементов в массиве (11). Имена массивов соответствуют тем же соглашениям, что и имена других переменных.

Индекс должен быть целочисленным или целочисленным выражением (используя любой целочисленный тип). Если программа использует выражение в качестве нижнего индекса, тогда программа оценивает выражение для определения нижнего индекса. Например, если мы предположим, что переменная a равна 5, а переменная b равна 6, то оператор добавляет 2 к элементу массива C [11].

Именованное имя массива является lvalue, его можно использовать в левой части присваивания, так же как и имена переменных, не являющихся массивами.

Рассмотрим подробнее массив C на данном рисунке. Имя всего массива — C. Его 11 элементов называются от C [0] до C [10]. Значение C [0] равно -45, значение C [1] равно 6, значение C [2] равно 0, значение C [7] равно 62, а значение C [10] равно 78.

Чтобы вывести сумму значений, содержащихся в первых трех элементах массива C, мы бы написали:

Serial.print (C[ 0 ] + C[ 1 ] + C[ 2 ] );

Чтобы разделить значение C [6] на 2 и присвоить результат переменной x, мы бы написали:

x = C[ 6 ] / 2;

Объявление массивов

Массивы занимают место в памяти. Чтобы указать тип элементов и количество элементов, требуемых массивом, используйте объявление в форме —

type arrayName [ arraySize ] ;

Компилятор резервирует соответствующий объем памяти. (Напомним, что объявление, которое резервирует память, более правильно известно как определение). ArraySize должен быть целочисленной константой, большей нуля. Например, чтобы сообщить компилятору зарезервировать 11 элементов для целочисленного массива C, используйте объявление —

int C[ 12 ]; // C is an array of 12 integers

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

Примеры использования массивов

В этом разделе приводится много примеров, демонстрирующих, как объявлять, инициализировать и манипулировать массивами.

Пример 1. Объявление массива и использование цикла для инициализации элементов массива.

Программа объявляет 10-элементный целочисленный массив n . Строки a – b используют оператор For для инициализации элементов массива нулями. Как и другие автоматические переменные, автоматические массивы неявно инициализируются нулем. Первый оператор вывода (строка c) отображает заголовки столбцов для столбцов, напечатанных в последующем операторе for (строки d – e), который печатает массив в табличном формате.

пример

int n[ 10 ] ; // n is an array of 10 integers

void setup () {

}

void loop () {
   for ( int i = 0; i < 10; ++i ) // initialize elements of array n to 0 {
      n[ i ] = 0; // set element at location i to 0
      Serial.print (i) ;
      Serial.print (‘\r’) ;
   }
   for ( int j = 0; j < 10; ++j ) // output each array element's value {
      Serial.print (n[j]) ;
      Serial.print (‘\r’) ;
   } 
}

Результат — это даст следующий результат —

Element
Value



0
1
2
3
4
5
6
7
8
9


0
0
0
0
0
0
0
0
0
0



0
1
2
3
4
5
6
7
8
9
0
0
0
0
0
0
0
0
0
0
  Пример 2. Инициализация массива в объявлении с помощью списка инициализаторов. 
  Элементы массива также можно инициализировать в объявлении массива, следуя имени массива со знаком равенства и разделенным запятыми списком инициализаторов, разделенных запятыми.  Программа использует список инициализаторов для инициализации целочисленного массива с 10 значениями (строка a) и печатает массив в табличном формате (строки b – c). 
  пример 
// n is an array of 10 integers
int n[ 10 ] = { 32, 27, 64, 18, 95, 14, 90, 70, 60, 37 } ;

void setup () {

}

void loop () {
   for ( int i = 0; i < 10; ++i ) {
      Serial.print (i) ;
      Serial.print (‘\r’) ;
   }
   for ( int j = 0; j < 10; ++j ) // output each array element's value {
      Serial.print (n[j]) ;
      Serial.print (‘\r’) ;
   } 
}
  Результат - это даст следующий результат - 


Element
Value



0
1
2
3
4
5
6
7
8
9


32
27
64
18
95
14
90
70
60
37



0
1
2
3
4
5
6
7
8
9
32
27
64
18
95
14
90
70
60
37
  Пример 3: суммирование элементов массива 
  Часто элементы массива представляют собой серию значений, которые будут использоваться в расчете.  Например, если элементы массива представляют оценки за экзамен, профессор может пожелать суммировать элементы массива и использовать эту сумму для расчета среднего балла за экзамен.  Программа суммирует значения, содержащиеся в 10-элементном целочисленном массиве a . 
  пример 
const int arraySize = 10; // constant variable indicating size of array
int a[ arraySize ] = { 87, 68, 94, 100, 83, 78, 85, 91, 76, 87 };
int total = 0;

void setup () {

}
void loop () {
   // sum contents of array a
   for ( int i = 0; i < arraySize; ++i )
      total += a[ i ];
   Serial.print (“Total of array elements : ”) ;
   Serial.print(total) ;
}
  Результат - это даст следующий результат - 
Total of array elements: 849

  Массивы важны для Arduino и должны уделять гораздо больше внимания.  Следующие важные понятия, связанные с массивом, должны быть понятны Arduino - 



  S.NO. 
  Концепция и описание 


  1 
  Передача массивов в функции 

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



  2 
  Многомерные массивы 

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




  Чтобы передать аргумент массива в функцию, укажите имя массива без скобок. 
  Массивы с двумя измерениями (т.е. индексы) часто представляют таблицы значений, состоящие из информации, расположенной в строках и столбцах. 
  Arduino - функции ввода / вывода 
  Контакты на плате Arduino могут быть сконфигурированы как входы или выходы.  Мы объясним функционирование контактов в этих режимах.  Важно отметить, что большинство аналоговых выводов Arduino могут быть сконфигурированы и использованы точно так же, как и цифровые выводы. 
  Пины настроены как ВХОД 
  Пины Arduino по умолчанию настроены как входы, поэтому их не нужно явно объявлять как входы с помощью pinMode (), когда вы используете их в качестве входов.  Считается, что выводы, настроенные таким образом, находятся в состоянии высокого импеданса.  Входные контакты предъявляют чрезвычайно малые требования к цепи, которую они дискретизируют, что эквивалентно последовательному резистору 100 мОм перед контактом. 
  Это означает, что для переключения входного контакта из одного состояния в другое требуется очень мало тока.  Это делает выводы полезными для таких задач, как реализация емкостного сенсорного датчика или считывание светодиода в качестве фотодиода. 
  Контакты, сконфигурированные как pinMode (pin, INPUT), к которым ничего не подключено, или с проводами, подключенными к ним, которые не подключены к другим цепям, сообщают о случайных изменениях состояния контактов, захвате электрических помех из окружающей среды или емкостной связи состояния соседней булавки. 
  Подтягивающие резисторы 
  Подтягивающие резисторы часто полезны для приведения входного контакта в известное состояние, если вход отсутствует.  Это можно сделать, добавив подтягивающий резистор (до + 5 В) или понижающий резистор (резистор к земле) на входе.  Резистор 10K является хорошим значением для резистора с повышением или понижением. 
  Использование встроенного подтягивающего резистора с выводами, настроенными в качестве входа 
  В микросхему Atmega встроено 20 000 подтягивающих резисторов, к которым можно получить доступ из программного обеспечения.  Доступ к этим встроенным нагрузочным резисторам можно получить, установив pinMode () как INPUT_PULLUP.  Это эффективно инвертирует поведение режима INPUT, где HIGH означает, что датчик выключен, а LOW означает, что датчик включен.  Значение этого подтягивания зависит от используемого микроконтроллера.  На большинстве плат на базе AVR это значение гарантируется в пределах от 20 кОм до 50 кОм.  На Arduino Due он составляет от 50 кОм до 150 кОм.  Для точного значения, обратитесь к спецификации микроконтроллера на вашей плате. 
  При подключении датчика к выводу, настроенному с помощью INPUT_PULLUP, другой конец должен быть заземлен.  В случае простого переключателя это заставляет штифт читать HIGH, когда переключатель разомкнут, и LOW, когда переключатель нажат.  Подтягивающие резисторы обеспечивают достаточный ток, чтобы зажечь светодиод, слабо подключенный к выводу, настроенному как вход.  Если кажется, что светодиоды в проекте работают, но очень тускло, это, вероятно, происходит. 
  Те же регистры (места внутренней памяти чипа), которые контролируют, является ли вывод ВЫСОКИМ или НИЗКИМ, управляют подтягивающими резисторами.  Следовательно, вывод, который настроен на включение подтягивающих резисторов, когда вывод находится в режиме INPUT, будет иметь вывод, настроенный как ВЫСОКИЙ, если вывод затем переключается в режим ВЫХОД с помощью pinMode ().  Это работает и в другом направлении, и на выходном выводе, который остается в ВЫСОКОМ состоянии, будет настроен подтягивающий резистор, если он переключен на вход с помощью pinMode (). 
  пример 
pinMode(3,INPUT) ; // set pin to input without using built in pull up resistor
pinMode(5,INPUT_PULLUP) ; // set pin to input using built in pull up resistor

  Пины настроены как выходной 
  Пины, настроенные как OUTPUT с pinMode (), как говорят, находятся в состоянии низкого сопротивления.  Это означает, что они могут обеспечить значительную величину тока для других цепей.  Контакты Atmega могут подавать (обеспечивать положительный ток) или потреблять (обеспечивать отрицательный ток) до 40 мА (миллиампер) тока на другие устройства / цепи.  Этого тока достаточно, чтобы ярко загореться светодиод (не забывайте о последовательном резисторе) или запустить много датчиков, но недостаточно тока для работы реле, соленоидов или двигателей. 
  Попытка запустить устройства с высоким током от выходных выводов может привести к повреждению или разрушению выходных транзисторов в выводе или повреждению всего чипа Atmega.  Часто это приводит к «мертвому» выводу в микроконтроллере, но оставшиеся микросхемы по-прежнему функционируют адекватно.  По этой причине рекомендуется подключать выводы OUTPUT к другим устройствам через резисторы сопротивлением 470 Ом или 1 кОм, если для конкретного применения не требуется максимальный ток, снимаемый с выводов. 
  Функция pinMode () 
  Функция pinMode () используется для настройки определенного вывода на поведение входа или выхода.  Внутренние подтягивающие резисторы можно включить в режиме INPUT_PULLUP.  Кроме того, режим INPUT явно отключает внутренние подтягивания. 
  pinMode () Синтаксис функции 
Void setup () {
   pinMode (pin , mode);
}



  pin - номер пина, режим которого вы хотите установить 


  режим - INPUT, OUTPUT или INPUT_PULLUP. 


  pin - номер пина, режим которого вы хотите установить 
  режим - INPUT, OUTPUT или INPUT_PULLUP. 
  пример 
int button = 5 ; // button connected to pin 5
int LED = 6; // LED connected to pin 6

void setup () {
   pinMode(button , INPUT_PULLUP); 
   // set the digital pin as input with pull-up resistor
   pinMode(button , OUTPUT); // set the digital pin as output
}

void setup () {
   If (digitalRead(button ) == LOW) // if button pressed {
      digitalWrite(LED,HIGH); // turn on led
      delay(500); // delay for 500 ms
      digitalWrite(LED,LOW); // turn off led
      delay(500); // delay for 500 ms
   }
}
  Функция digitalWrite () 
  Функция digitalWrite () используется для записи значения HIGH или LOW на цифровой вывод.  Если вывод был сконфигурирован как OUTPUT с помощью pinMode () , его напряжение будет установлено на соответствующее значение: 5 В (или 3,3 В на платах 3,3 В) для ВЫСОКОГО, 0 В (заземление) для НИЗКОГО.  Если вывод сконфигурирован как INPUT, digitalWrite () активирует (HIGH) или отключает (LOW) внутреннее подтягивание на входном выводе.  Рекомендуется установить для pinMode () значение INPUT_PULLUP, чтобы включить внутренний подтягивающий резистор. 
  Если вы не установили pinMode () на OUTPUT и подключили светодиод к контакту, то при вызове digitalWrite (HIGH) светодиод может выглядеть тусклым.  Без явной установки pinMode () digitalWrite () включит внутренний подтягивающий резистор, который действует как большой ограничивающий ток резистор. 
  Синтаксис функции digitalWrite () 
Void loop() {
   digitalWrite (pin ,value);
}



  pin - номер пина, режим которого вы хотите установить 


  значение - ВЫСОКОЕ или НИЗКОЕ. 


  pin - номер пина, режим которого вы хотите установить 
  значение - ВЫСОКОЕ или НИЗКОЕ. 
  пример 
int LED = 6; // LED connected to pin 6

void setup () {
   pinMode(LED, OUTPUT); // set the digital pin as output
}

void setup () { 
   digitalWrite(LED,HIGH); // turn on led
   delay(500); // delay for 500 ms
   digitalWrite(LED,LOW); // turn off led
   delay(500); // delay for 500 ms
}
  функция analogRead () 
  Arduino может определить, есть ли напряжение на одном из его выводов, и сообщить об этом через функцию digitalRead ().  Существует разница между датчиком включения / выключения (который обнаруживает присутствие объекта) и аналоговым датчиком, значение которого постоянно изменяется.  Чтобы прочитать этот тип датчика, нам нужен другой тип булавки. 
  В правой нижней части платы Arduino вы увидите шесть выводов с пометкой «Analog In».  Эти специальные контакты показывают не только напряжение, приложенное к ним, но и его значение.  Используя функцию analogRead () , мы можем прочитать напряжение, приложенное к одному из выводов. 
  Эта функция возвращает число от 0 до 1023, которое представляет напряжения от 0 до 5 вольт.  Например, если на вывод № 0 подается напряжение 2,5 В, analogRead (0) возвращает 512. 
  Синтаксис функции analogRead () 
analogRead(pin);



  pin - номер вывода аналогового входа для чтения (от 0 до 5 на большинстве плат, от 0 до 7 на Mini и Nano, от 0 до 15 на Mega) 


  pin - номер вывода аналогового входа для чтения (от 0 до 5 на большинстве плат, от 0 до 7 на Mini и Nano, от 0 до 15 на Mega) 
  пример 
int analogPin = 3;//potentiometer wiper (middle terminal) 
   // connected to analog pin 3 
int val = 0; // variable to store the value read

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

void loop() {
   val = analogRead(analogPin); // read the input pin
   Serial.println(val); // debug value
}
  Arduino - Усовершенствованная функция ввода / вывода 
  В этой главе мы изучим некоторые расширенные функции ввода и вывода. 
  Функция analogReference () 
  Настройка опорного напряжения, используемое для аналогового входа (то есть значение, используемое в качестве верхней части входного диапазона).  Варианты - 


  ПО УМОЛЧАНИЮ - аналоговое задание по умолчанию 5 В (на платах Arduino 5 В) или 3,3 В (на платах Arduino 3,3 В) 


  ВНУТРЕННИЙ - встроенный опорный сигнал, равный 1,1 В на ATmega168 или ATmega328 и 2,56 В на ATmega8 (недоступно на Arduino Mega) 


  INTERNAL1V1 - Встроенный эталон 1,1 В (только Arduino Mega) 


  INTERNAL2V56 - встроенный эталон на 2,56 В (только Arduino Mega) 


  ВНЕШНЕЕ - Напряжение, приложенное к выводу AREF (только от 0 до 5 В), используется в качестве эталона 


  ПО УМОЛЧАНИЮ - аналоговое задание по умолчанию 5 В (на платах Arduino 5 В) или 3,3 В (на платах Arduino 3,3 В) 
  ВНУТРЕННИЙ - встроенный опорный сигнал, равный 1,1 В на ATmega168 или ATmega328 и 2,56 В на ATmega8 (недоступно на Arduino Mega) 
  INTERNAL1V1 - Встроенный эталон 1,1 В (только Arduino Mega) 
  INTERNAL2V56 - встроенный эталон на 2,56 В (только Arduino Mega) 
  ВНЕШНЕЕ - Напряжение, приложенное к выводу AREF (только от 0 до 5 В), используется в качестве эталона 
  analogReference () Синтаксис функции 
analogReference (type);

  тип - может использовать любой тип следующего (DEFAULT, INTERNAL, INTERNAL1V1, INTERNAL2V56, EXTERNAL) 
  Есть ли что-нибудь меньше, чем 0В или больше, чем 5В для внешнего опорного напряжения на Ареф штифтом не использовать.  Если вы используете внешнюю ссылку на выводе AREF, вы должны установить аналоговую ссылку на EXTERNAL перед вызовом функции analogRead () .  В противном случае, вы будете короткий активный источник опорного напряжения (внутренне генерируется) и AREF контактный, возможно, повреждая микроконтроллер на доске Arduino. 

  Кроме того, вы можете подключить внешний источник опорного напряжения к AREF штифтом через резистор 5K, что позволяет переключаться между внешними и внутренними опорными напряжениями. 
  Обратите внимание, что резистор изменит напряжение, которое используется в качестве эталона, потому что на выводе AREF имеется внутренний резистор 32 кОм.  Эти два действуют как делитель напряжения.  Например, 2,5 В, приложенное через резистор, даст 2,5 * 32 / (32 + 5) = ~ 2,2 В на выводе AREF. 
  пример 
int analogPin = 3;// potentiometer wiper (middle terminal) connected to analog pin 3 
int val = 0; // variable to store the read value

void setup() {
   Serial.begin(9600); // setup serial
   analogReference(EXTERNAL); // the voltage applied to the AREF pin (0 to 5V only) 
      // is used as the reference.
}

void loop() {
   val = analogRead(analogPin); // read the input pin
   Serial.println(val); // debug value
}
  Arduino - Функции персонажей 
  Все данные вводятся в компьютеры в виде символов, которые включают буквы, цифры и различные специальные символы.  В этом разделе мы обсудим возможности C ++ для изучения и управления отдельными символами. 
  Библиотека обработки символов включает в себя несколько функций, которые выполняют полезные тесты и манипуляции с символьными данными.  Каждая функция получает символ, представленный как int, или EOF в качестве аргумента.  Символами часто манипулируют как целыми числами. 
  Помните, что EOF обычно имеет значение -1 и что некоторые аппаратные архитектуры не позволяют хранить отрицательные значения в переменных типа char.  Поэтому функции обработки символов обрабатывают символы как целые числа. 
  В следующей таблице приведены функции библиотеки обработки символов.  При использовании функций из библиотеки обработки символов включайте заголовок <cctype> . 



  S.No. 
  Прототип и описание 


  1 

  int isdigit (int c) 
  Возвращает 1, если c является цифрой, и 0 в противном случае. 



  2 

  int isalpha (int c) 
  Возвращает 1, если c является буквой, и 0 в противном случае. 



  3 

  int isalnum (int c) 
  Возвращает 1, если c является цифрой или буквой, и 0 в противном случае. 



  4 

  int isxdigit (int c) 
  Возвращает 1, если c - шестнадцатеричный символ, и 0 в противном случае. 
  (См. Приложение D, Системы счисления, для подробного объяснения двоичных, восьмеричных, десятичных и шестнадцатеричных чисел.) 



  5 

  int islower (int c) 
  Возвращает 1, если c строчная буква, и 0 в противном случае. 



  6 

  int isupper (int c) 
  Возвращает 1, если c - заглавная буква;  0 иначе 



  7 

  int isspace (int c) 
  Возвращает 1, если c является символом пробела - символ новой строки ('\ n'), пробел 
  (''), подача формы ('\ f'), возврат каретки ('\ r'), горизонтальная табуляция ('\ t') или вертикальная табуляция ('\ v') - и 0 в противном случае. 



  8 

  int iscntrl (int c) 
  Возвращает 1, если c является управляющим символом, таким как символ новой строки ('\ n'), перевод формы ('\ f'), возврат каретки ('\ r'), горизонтальная табуляция ('\ t'), вертикальная табуляция (' \ v '), alert (' \ a ') или backspace (' \ b ') - и 0 в противном случае. 



  9 

  int ispunct (int c) 
  Возвращает 1, если c - это печатный символ, отличный от пробела, цифры или буквы, и 0 в противном случае. 



  10 

  int isprint (int c) 
  Возвращает 1, если c является печатным символом, включающим пробел (''), и 0 в противном случае. 



  11 

  int isgraph (int c) 
  Возвращает 1, если c - это печатающий символ, отличный от пробела (''), и 0 в противном случае. 




  int isdigit (int c) 
  Возвращает 1, если c является цифрой, и 0 в противном случае. 
  int isalpha (int c) 
  Возвращает 1, если c является буквой, и 0 в противном случае. 
  int isalnum (int c) 
  Возвращает 1, если c является цифрой или буквой, и 0 в противном случае. 
  int isxdigit (int c) 
  Возвращает 1, если c - шестнадцатеричный символ, и 0 в противном случае. 
  (См. Приложение D, Системы счисления, для подробного объяснения двоичных, восьмеричных, десятичных и шестнадцатеричных чисел.) 
  int islower (int c) 
  Возвращает 1, если c строчная буква, и 0 в противном случае. 
  int isupper (int c) 
  Возвращает 1, если c - заглавная буква;  0 иначе 
  int isspace (int c) 
  Возвращает 1, если c является символом пробела - символ новой строки ('\ n'), пробел 
  (''), подача формы ('\ f'), возврат каретки ('\ r'), горизонтальная табуляция ('\ t') или вертикальная табуляция ('\ v') - и 0 в противном случае. 
  int iscntrl (int c) 
  Возвращает 1, если c является управляющим символом, таким как символ новой строки ('\ n'), перевод формы ('\ f'), возврат каретки ('\ r'), горизонтальная табуляция ('\ t'), вертикальная табуляция (' \ v '), alert (' \ a ') или backspace (' \ b ') - и 0 в противном случае. 
  int ispunct (int c) 
  Возвращает 1, если c - это печатный символ, отличный от пробела, цифры или буквы, и 0 в противном случае. 
  int isprint (int c) 
  Возвращает 1, если c является печатным символом, включающим пробел (''), и 0 в противном случае. 
  int isgraph (int c) 
  Возвращает 1, если c - это печатающий символ, отличный от пробела (''), и 0 в противном случае. 
  Примеры 
  В следующем примере демонстрируется использование функций isdigit, isalpha, isalnum и isxdigit .  Функция isdigit определяет, является ли ее аргумент цифрой (0–9).  Функция isalpha определяет, является ли ее аргумент заглавной буквой (AZ) или строчной буквой (a – z).  Функция isalnum определяет, является ли ее аргумент заглавной, строчной буквой или цифрой.  Функция isxdigit определяет, является ли ее аргумент шестнадцатеричной цифрой (A – F, a – f, 0–9). 
  Пример 1 
void setup () {
   Serial.begin (9600);
   Serial.print ("According to isdigit:\r");
   Serial.print (isdigit( '8' ) ? "8 is a": "8 is not a");
   Serial.print (" digit\r" );
   Serial.print (isdigit( '8' ) ?"# is a": "# is not a") ;
   Serial.print (" digit\r");
   Serial.print ("\rAccording to isalpha:\r" );
   Serial.print (isalpha('A' ) ?"A is a": "A is not a");
   Serial.print (" letter\r");
   Serial.print (isalpha('A' ) ?"b is a": "b is not a");
   Serial.print (" letter\r");
   Serial.print (isalpha('A') ?"& is a": "& is not a");
   Serial.print (" letter\r");
   Serial.print (isalpha( 'A' ) ?"4 is a":"4 is not a");
   Serial.print (" letter\r");
   Serial.print ("\rAccording to isalnum:\r");
   Serial.print (isalnum( 'A' ) ?"A is a" : "A is not a" );

   Serial.print (" digit or a letter\r" );
   Serial.print (isalnum( '8' ) ?"8 is a" : "8 is not a" ) ;
   Serial.print (" digit or a letter\r");
   Serial.print (isalnum( '#' ) ?"# is a" : "# is not a" );
   Serial.print (" digit or a letter\r");
   Serial.print ("\rAccording to isxdigit:\r");
   Serial.print (isxdigit( 'F' ) ?"F is a" : "F is not a" );
   Serial.print (" hexadecimal digit\r" );
   Serial.print (isxdigit( 'J' ) ?"J is a" : "J is not a" ) ;
   Serial.print (" hexadecimal digit\r" );
   Serial.print (isxdigit( '7' ) ?"7 is a" : "7 is not a" ) ;

   Serial.print (" hexadecimal digit\r" );
   Serial.print (isxdigit( '$' ) ? "$ is a" : "$ is not a" );
   Serial.print (" hexadecimal digit\r" );
   Serial.print (isxdigit( 'f' ) ? “f is a" : "f is not a");
   
}

void loop () {

}
  Результат 
According to isdigit:
8 is a digit
# is not a digit
According to isalpha:
A is a letter
b is a letter
& is not a letter
4 is not a letter
According to isalnum:
A is a digit or a letter

8 is a digit or a letter
# is not a digit or a letter
According to isxdigit:
F is a hexadecimal digit
J is not a hexadecimal digit
7 is a hexadecimal digit

$ is not a hexadecimal digit
f is a hexadecimal digit

  Мы используем условный оператор (? 🙂 с каждой функцией, чтобы определить, должна ли строка «is a» или строка «not a» печататься в выходных данных для каждого тестируемого символа.  Например, строка a указывает, что если '8' является цифрой, т. Е. Если isdigit возвращает истинное (ненулевое) значение, то строка "8 is a" печатается.  Если '8' не является цифрой (то есть, если isdigit возвращает 0), выводится строка "8 не является". 
  Пример 2 
  В следующем примере демонстрируется использование функций islower и isupper .  Функция islower определяет, является ли ее аргумент строчной буквой (a – z).  Функция isupper определяет, является ли ее аргумент заглавной буквой (A – Z). 
int thisChar = 0xA0;

void setup () {
   Serial.begin (9600);
   Serial.print ("According to islower:\r") ;
   Serial.print (islower( 'p' ) ? "p is a" : "p is not a" );
   Serial.print ( " lowercase letter\r" );
   Serial.print ( islower( 'P') ? "P is a" : "P is not a") ;
   Serial.print ("lowercase letter\r");
   Serial.print (islower( '5' ) ? "5 is a" : "5 is not a" );
   Serial.print ( " lowercase letter\r" );
   Serial.print ( islower( '!' )? "! is a" : "! is not a") ;
   Serial.print ("lowercase letter\r");

   Serial.print ("\rAccording to isupper:\r") ;
   Serial.print (isupper ( 'D' ) ? "D is a" : "D is not an" );
   Serial.print ( " uppercase letter\r" );
   Serial.print ( isupper ( 'd' )? "d is a" : "d is not an") ;
   Serial.print ( " uppercase letter\r" );
   Serial.print (isupper ( '8' ) ? "8 is a" : "8 is not an" );
   Serial.print ( " uppercase letter\r" );
   Serial.print ( islower( '$' )? "$ is a" : "$ is not an") ;
   Serial.print ("uppercase letter\r ");
}

void setup () {

}
  Результат 
According to islower:
p is a lowercase letter
P is not a lowercase letter
5 is not a lowercase letter
! is not a lowercase letter

According to isupper:
D is an uppercase letter
d is not an uppercase letter
8 is not an uppercase letter
$ is not an uppercase letter

  Пример 3 
  В следующем примере демонстрируется использование функций isspace, iscntrl, ispunct, isprint и isgraph . 


  Функция isspace определяет, является ли ее аргумент символом пробела, таким как пробел (''), перевод формы ('\ f'), перевод строки ('\ n'), возврат каретки ('\ r'), горизонтальная табуляция ('\ t') или вертикальная вкладка ('\ v'). 


  Функция iscntrl определяет, является ли ее аргумент управляющим символом, таким как горизонтальная табуляция ('\ t'), вертикальная табуляция ('\ v'), подача формы ('\ f'), предупреждение ('\ a'), возврат на одну позицию ( '\ b'), возврат каретки ('\ r') или перевод строки ('\ n'). 


  Функция ispunct определяет, является ли ее аргумент печатным символом, отличным от пробела, цифры или буквы, например, $, #, (,), [,], {,},;,: или%. 


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


  Функция isgraph проверяет те же символы, что и isprint, но пробел не включается. 


  Функция isspace определяет, является ли ее аргумент символом пробела, таким как пробел (''), перевод формы ('\ f'), перевод строки ('\ n'), возврат каретки ('\ r'), горизонтальная табуляция ('\ t') или вертикальная вкладка ('\ v'). 
  Функция iscntrl определяет, является ли ее аргумент управляющим символом, таким как горизонтальная табуляция ('\ t'), вертикальная табуляция ('\ v'), подача формы ('\ f'), предупреждение ('\ a'), возврат на одну позицию ( '\ b'), возврат каретки ('\ r') или перевод строки ('\ n'). 
  Функция ispunct определяет, является ли ее аргумент печатным символом, отличным от пробела, цифры или буквы, например, $, #, (,), [,], {,},;,: или%. 
  Функция isprint определяет, является ли ее аргумент символом, который может отображаться на экране (включая символ пробела). 
  Функция isgraph проверяет те же символы, что и isprint, но пробел не включается. 
void setup () {
   Serial.begin (9600);
   Serial.print ( " According to isspace:\rNewline ") ;
   Serial.print (isspace( '\n' )? " is a" : " is not a" );
   Serial.print ( " whitespace character\rHorizontal tab") ;
   Serial.print (isspace( '\t' )? " is a" : " is not a" );
   Serial.print ( " whitespace character\n") ;
   Serial.print (isspace('%')? " % is a" : " % is not a" );
   
   Serial.print ( " \rAccording to iscntrl:\rNewline") ;
   Serial.print ( iscntrl( '\n' )?"is a" : " is not a" ) ;
   Serial.print (" control character\r");
   Serial.print (iscntrl( '$' ) ? " $ is a" : " $ is not a" );
   Serial.print (" control character\r");
   Serial.print ("\rAccording to ispunct:\r");
   Serial.print (ispunct(';' ) ?"; is a" : "; is not a" ) ;
   Serial.print (" punctuation character\r");
   Serial.print (ispunct('Y' ) ?"Y is a" : "Y is not a" ) ;
   Serial.print ("punctuation character\r");
   Serial.print (ispunct('#' ) ?"# is a" : "# is not a" ) ;
   Serial.print ("punctuation character\r");

   Serial.print ( "\r According to isprint:\r");
   Serial.print (isprint('$' ) ?"$ is a" : "$ is not a" );
   Serial.print (" printing character\rAlert ");
   Serial.print (isprint('\a' ) ?" is a" : " is not a" );
   Serial.print (" printing character\rSpace ");
   Serial.print (isprint(' ' ) ?" is a" : " is not a" );
   Serial.print (" printing character\r");
   
   Serial.print ("\r According to isgraph:\r");
   Serial.print (isgraph ('Q' ) ?"Q is a" : "Q is not a" );
   Serial.print ("printing character other than a space\rSpace ");
   Serial.print (isgraph (' ') ?" is a" : " is not a" );
   Serial.print ("printing character other than a space ");
}

void loop () {

}
  Результат 
According to isspace:
Newline is a whitespace character
Horizontal tab is a whitespace character
% is not a whitespace character
According to iscntrl:
Newline is a control character
$ is not a control character
According to ispunct:
; is a punctuation character
Y is not a punctuation character
# is a punctuation character
According to isprint:
$ is a printing character
Alert is not a printing character
Space is a printing character
According to isgraph:
Q is a printing character other than a space
Space is not a printing character other than a space

  Arduino - математическая библиотека 
  Библиотека Arduino Math (math.h) включает в себя ряд полезных математических функций для работы с числами с плавающей точкой. 
  Макросы библиотеки 
  Ниже приведены макросы, определенные в заголовке math.h - 
   Ниже приведен список макросов, определенных в заголовке math.h 





  макрос 
  Значение 
  Описание 


  МНЕ 
  +2,7182818284590452354 
  Константа е. 


  M_LOG2E 

  +1,4426950408889634074 
  / * log_2 e * / 

  Логарифм по основанию 2 


  M_1_PI 

  +0,31830988618379067154 
  / * 1 / пи * / 

  Константа 1 / пи 


  M_2_PI 

  +0,63661977236758134308 
  / * 2 / пи * / 

  Константа 2 / пи 


  M_2_SQRTPI 

  +1,12837916709551257390 
  / * 2 / sqrt (pi) * / 

  Константа 2 / квт (пи) 


  M_LN10 

  +2,30258509299404568402 
  / * log_e 10 * / 

  Натуральный логарифм 10 


  M_LN2 

  +0,69314718055994530942 
  / * log_e 2 * / 

  Натуральный логарифм 2 


  M_LOG10E 

  +0,43429448190325182765 
  / * log_10 e * / 

  Логарифм по основанию 10 


  M_PI 

  +3,14159265358979323846 
  /* число Пи */ 

  Постоянная пи 


  M_PI_2 

  3.3V1.57079632679489661923 
  / * пи / 2 * / 

  Константа пи / 2 


  M_PI_4 

  +0,78539816339744830962 
  / * пи / 4 * / 

  Константа пи / 4 


  M_SQRT1_2 

  +0,70710678118654752440 
  / * 1 / sqrt (2) * / 

  Константа 1 / кв.м (2) 


  M_SQRT2 

  +1,41421356237309504880 
  / * sqrt (2) * / 

  Квадратный корень из 2 


  acosf 
  - 
  Псевдоним для функции acos () 


  asinf 
  - 
  Псевдоним для функции asin () 


  atan2f 
  - 
  Псевдоним для функции atan2 () 


  cbrtf 
  - 
  Псевдоним для функции cbrt () 


  ceilf 
  - 
  Псевдоним для функции ceil () 


  copysignf 
  - 
  Псевдоним для функции copysign () 


  coshf 
  - 
  Псевдоним для функции cosh () 


  ехр 
  - 
  Псевдоним для функции exp () 


  fabsf 
  - 
  Псевдоним для функции fabs () 


  fdimf 
  - 
  Псевдоним для функции fdim () 


  floorf 
  - 
  Псевдоним для функции floor () 


  fmaxf 
  - 
  Псевдоним для функции fmax () 


  fminf 
  - 
  Псевдоним для функции fmin () 


  fmodf 
  - 
  Псевдоним для функции fmod () 


  frexpf 
  - 
  Псевдоним для функции frexp () 


  hypotf 
  - 
  Псевдоним для функции hypot () 


  INFINITY 
  - 
  Постоянство бесконечности 


  isfinitef 
  - 
  Псевдоним для функции isfinite () 


  isinff 
  - 
  Псевдоним для функции isinf () 


  isnanf 
  - 
  Псевдоним для функции isnan () 


  ldexpf 
  - 
  Псевдоним для функции ldexp () 


  log10f 
  - 
  Псевдоним для функции log10 () 


  logf 
  - 
  Псевдоним для функции log () 


  lrintf 
  - 
  Псевдоним для функции lrint () 


  lroundf 
  - 
  Псевдоним для функции lround () 





  +1,4426950408889634074 
  / * log_2 e * / 
  +0,31830988618379067154 
  / * 1 / пи * / 
  +0,63661977236758134308 
  / * 2 / пи * / 
  +1,12837916709551257390 
  / * 2 / sqrt (pi) * / 
  +2,30258509299404568402 
  / * log_e 10 * / 
  +0,69314718055994530942 
  / * log_e 2 * / 
  +0,43429448190325182765 
  / * log_10 e * / 
  +3,14159265358979323846 
  /* число Пи */ 
  3.3V1.57079632679489661923 
  / * пи / 2 * / 
  +0,78539816339744830962 
  / * пи / 4 * / 
  +0,70710678118654752440 
  / * 1 / sqrt (2) * / 
  +1,41421356237309504880 
  / * sqrt (2) * / 
  Функции библиотеки 
  Следующие функции определены в заголовке math.h - 
  Ниже приведен список функций, определенных в заголовке math.h 





  S.No. 
  Функция и описание библиотеки 


  1 

  двойной акос (двойной __x) 
  Функция acos () вычисляет главное значение арккосинуса __x.  Возвращаемое значение находится в диапазоне [0, pi] радиан.  Ошибка домена возникает для аргументов, не входящих в диапазон [-1, +1]. 



  2 

  двойной asin (двойной __x) 
  Функция asin () вычисляет главное значение арксинуса __x.  Возвращаемое значение находится в диапазоне [-pi / 2, pi / 2] радиан.  Ошибка домена возникает для аргументов, не входящих в диапазон [-1, +1]. 



  3 

  двойной атан (двойной __x) 
  Функция atan () вычисляет главное значение арктангенса __x.  Возвращаемое значение находится в диапазоне [-pi / 2, pi / 2] радиан. 



  4 

  двойной atan2 (двойной __y, двойной __x) 
  Функция atan2 () вычисляет главное значение арктангенса __y / __x, используя знаки обоих аргументов для определения квадранта возвращаемого значения.  Возвращаемое значение находится в диапазоне [-pi, + pi] радиан. 



  5 

  двойной cbrt (двойной __x) 
  Функция cbrt () возвращает корень куба __x. 



  6 

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



  7 

  статический двойной copysign (двойной __x, двойной __y) 
  Функция copysign () возвращает __x, но со знаком __y.  Они работают, даже если __x или __y имеют значение NaN или ноль. 



  8 

  double cos (double __x) 
  Функция cos () возвращает косинус __x, измеренный в радианах. 



  9 

  двойной кош (двойной __x) 
  Функция cosh () возвращает гиперболический косинус __x. 



  10 

  двойной опыт (двойной __x) 
  Функция exp () возвращает экспоненциальное значение __x. 



  11 

  двойные fabs (двойной __x) 
  Функция fabs () вычисляет абсолютное значение числа с плавающей точкой __x. 



  12 

  двойной fdim (двойной __x, двойной __y) 
  Функция fdim () возвращает max (__ x - __y, 0).  Если __x или __y или оба имеют значение NaN, возвращается NaN. 



  13 

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



  14 

  двойной fma (двойной __x, двойной __y, двойной __z) 
  Функция fma () выполняет умножение-сложение с плавающей точкой.  Это операция (__x * __y) + __z, но промежуточный результат не округляется до целевого типа.  Это иногда может улучшить точность расчета. 



  15 

  двойной fmax (двойной __x, двойной __y) 
  Функция fmax () возвращает большее из двух значений __x и __y.  Если аргумент равен NaN, возвращается другой аргумент.  Если оба аргумента являются NaN, NaN возвращается. 



  16 

  двойной фмин (двойной __x, двойной __y) 
  Функция fmin () возвращает меньшее из двух значений __x и __y.  Если аргумент равен NaN, возвращается другой аргумент.  Если оба аргумента являются NaN, NaN возвращается. 



  17 

  double fmod (double __x, double__y) 
  Функция fmod () возвращает остаток с плавающей точкой от __x / __y. 



  18 

  double frexp (double __x, int * __pexp) 
  Функция frexp () разбивает число с плавающей запятой на нормализованную дробь и целую степень 2. Она сохраняет целое число в объекте int, на который указывает __pexp.  Если __x является нормальным числом с плавающей запятой, функция frexp () возвращает значение v, так что v имеет величину в интервале [1/2, 1) или ноль, а __x равно v умноженному на 2, возведенному в степень __pexp.  Если __x равен нулю, обе части результата равны нулю.  Если __x не является конечным числом, frexp () возвращает __x как есть и сохраняет 0 в __pexp. 
  Примечание. Эта реализация разрешает указатель нуля в качестве директивы, чтобы пропустить сохранение показателя степени. 



  19 

  двойной гипотет (двойной __x, двойной __y) 
  Функция hypot () возвращает sqrt (__x * __x + __y * __y).  Это длина гипотенузы прямоугольного треугольника со сторонами длины __x и __y или расстояние от точки (__x, __y) до начала координат.  Использование этой функции вместо прямой формулы целесообразно, поскольку ошибка намного меньше.  Нет недостатка с маленькими __x и __y.  Нет переполнения, если результат находится в диапазоне. 



  20 

  static int isfinite (double __x) 
  Функция isfinite () возвращает ненулевое значение, если __x конечно: не плюс или минус бесконечность и не NaN . 



  21 

  int isinf (двойной __x) 
  Функция isinf () возвращает 1, если аргумент __x является положительной бесконечностью, -1, если __x является отрицательной бесконечностью, и 0 в противном случае. 
  Примечание . GCC 4.3 может заменить эту функцию встроенным кодом, который возвращает значение 1 для обеих бесконечностей (ошибка gcc # 35509). 



  22 

  int isnan (двойной __x) 
  Функция isnan () возвращает 1, если аргумент __x представляет объект «не число» ( NaN ), иначе 0. 



  23 

  double ldexp (double __x, int __exp) 
  Функция ldexp () умножает число с плавающей запятой на целую степень 2. Она возвращает значение __x умноженное на 2, возведенное в степень __exp. 



  24 

  двойной журнал (двойной __x) 
  Функция log () возвращает натуральный логарифм аргумента __x. 



  25 

  двойной log10 (двойной __x) 
  Функция log10 () возвращает логарифм аргумента __x в основание 10. 



  26 

  длинный лринт (двойной __x) 
  Функция lrint () округляет __x до ближайшего целого, округляя полпути до четного целочисленного направления.  (То есть 1,5 и 2,5 значения округляются до 2).  Эта функция похожа на функцию rint (), но отличается по типу возвращаемого значения и тем, что возможно переполнение. 
  Возвращает 
  Округленное длинное целое значение.  Если __x не является конечным числом или переполнением, эта реализация возвращает значение LONG_MIN (0x80000000). 



  27 

  длинная земля (двойная __x) 
  Функция lround () округляет __x до ближайшего целого числа, но округляет значения на полпути от нуля (вместо ближайшего четного целого).  Эта функция похожа на функцию round (), но отличается по типу возвращаемого значения и тем, что возможно переполнение. 
  Возвращает 
  Округленное длинное целое значение.  Если __x не является конечным числом или было переполнение, эта реализация возвращает значение LONG_MIN (0x80000000). 



  28 

  двойной модф (двойной __x, двойной * __iptr) 
  Функция modf () разбивает аргумент __x на целые и дробные части, каждая из которых имеет тот же знак, что и аргумент.  Он хранит неотъемлемую часть как двойную в объекте, на который указывает __iptr. 
  Функция modf () возвращает дробную часть со знаком __x. 
  Примечание. Эта реализация пропускает запись по нулевому указателю.  Однако GCC 4.3 может заменить эту функцию встроенным кодом, который не позволяет использовать NULL-адрес для избежания сохранения. 



  29 

  float modff (float __x, float * __iptr) 
  Псевдоним для modf (). 



  30 

  двойной пау (двойной __x, двойной __y) 
  Функция pow () возвращает значение __x показателю __y. 



  31 

  двойной раунд (двойной __x) 
  Функция round () округляет __x до ближайшего целого числа, но округляет полпути до нуля (вместо ближайшего четного целого).  Переполнение невозможно. 
  Возвращает 
  Округленное значение.  Если __x является целым или бесконечным, возвращается сам __x.  Если __x равен NaN , то возвращается NaN . 



  32 

  int signbit (двойной __x) 
  Функция signbit () возвращает ненулевое значение, если значение __x имеет установленный знаковый бит.  Это не то же самое, что __x <0.0, потому что с плавающей точкой IEEE 754 позволяет подписать ноль.  Сравнение `-0.0 <0.0 'ложно, но` signbit (-0.0)' вернет ненулевое значение. 



  33 

  двойной грех (двойной __x) 
  Функция sin () возвращает синус __x, измеренный в радианах. 



  34 

  двойной синх (двойной __x) 
  Функция sinh () возвращает гиперболический синус __x. 



  35 

  двойной квадрат (двойной __x) 
  Функция sqrt () возвращает неотрицательный квадратный корень из __x. 



  36 

  двойной квадрат (двойной __x) 
  Функция square () возвращает __x * __x. 
  Примечание. Эта функция не относится к стандартному определению языка Си. 



  37 

  двойной загар (двойной __x) 
  Функция tan () возвращает тангенс __x, измеренный в радианах. 



  38 

  двойной танх (двойной __x) 
  Функция tanh () возвращает гиперболический тангенс __x. 



  39 

  двойное усечение (двойное __x) 
  Функция trunc () округляет __x до ближайшего целого числа, не большего по абсолютной величине. 






  двойной акос (двойной __x) 
  Функция acos () вычисляет главное значение арккосинуса __x.  Возвращаемое значение находится в диапазоне [0, pi] радиан.  Ошибка домена возникает для аргументов, не входящих в диапазон [-1, +1]. 
  двойной asin (двойной __x) 
  Функция asin () вычисляет главное значение арксинуса __x.  Возвращаемое значение находится в диапазоне [-pi / 2, pi / 2] радиан.  Ошибка домена возникает для аргументов, не входящих в диапазон [-1, +1]. 
  двойной атан (двойной __x) 
  Функция atan () вычисляет главное значение арктангенса __x.  Возвращаемое значение находится в диапазоне [-pi / 2, pi / 2] радиан. 
  двойной atan2 (двойной __y, двойной __x) 
  Функция atan2 () вычисляет главное значение арктангенса __y / __x, используя знаки обоих аргументов для определения квадранта возвращаемого значения.  Возвращаемое значение находится в диапазоне [-pi, + pi] радиан. 
  двойной cbrt (двойной __x) 
  Функция cbrt () возвращает корень куба __x. 
  двойной потолок (двойной __x) 
  Функция ceil () возвращает наименьшее целочисленное значение, большее или равное __x, выраженное в виде числа с плавающей запятой. 
  статический двойной copysign (двойной __x, двойной __y) 
  Функция copysign () возвращает __x, но со знаком __y.  Они работают, даже если __x или __y имеют значение NaN или ноль. 
  double cos (double __x) 
  Функция cos () возвращает косинус __x, измеренный в радианах. 
  двойной кош (двойной __x) 
  Функция cosh () возвращает гиперболический косинус __x. 
  двойной опыт (двойной __x) 
  Функция exp () возвращает экспоненциальное значение __x. 
  двойные fabs (двойной __x) 
  Функция fabs () вычисляет абсолютное значение числа с плавающей точкой __x. 
  двойной fdim (двойной __x, двойной __y) 
  Функция fdim () возвращает max (__ x - __y, 0).  Если __x или __y или оба имеют значение NaN, возвращается NaN. 
  двойной этаж (двойной __x) 
  Функция floor () возвращает наибольшее целочисленное значение, меньшее или равное __x, выраженное в виде числа с плавающей запятой. 
  двойной fma (двойной __x, двойной __y, двойной __z) 
  Функция fma () выполняет умножение-сложение с плавающей точкой.  Это операция (__x * __y) + __z, но промежуточный результат не округляется до целевого типа.  Это иногда может улучшить точность расчета. 
  двойной fmax (двойной __x, двойной __y) 
  Функция fmax () возвращает большее из двух значений __x и __y.  Если аргумент равен NaN, возвращается другой аргумент.  Если оба аргумента являются NaN, NaN возвращается. 
  двойной фмин (двойной __x, двойной __y) 
  Функция fmin () возвращает меньшее из двух значений __x и __y.  Если аргумент равен NaN, возвращается другой аргумент.  Если оба аргумента являются NaN, NaN возвращается. 
  double fmod (double __x, double__y) 
  Функция fmod () возвращает остаток с плавающей точкой от __x / __y. 
  double frexp (double __x, int * __pexp) 
  Функция frexp () разбивает число с плавающей запятой на нормализованную дробь и целую степень 2. Она сохраняет целое число в объекте int, на который указывает __pexp.  Если __x является нормальным числом с плавающей запятой, функция frexp () возвращает значение v, так что v имеет величину в интервале [1/2, 1) или ноль, а __x равно v умноженному на 2, возведенному в степень __pexp.  Если __x равен нулю, обе части результата равны нулю.  Если __x не является конечным числом, frexp () возвращает __x как есть и сохраняет 0 в __pexp. 
  Примечание. Эта реализация разрешает указатель нуля в качестве директивы, чтобы пропустить сохранение показателя степени. 
  двойной гипотет (двойной __x, двойной __y) 
  Функция hypot () возвращает sqrt (__x * __x + __y * __y).  Это длина гипотенузы прямоугольного треугольника со сторонами длины __x и __y или расстояние от точки (__x, __y) до начала координат.  Использование этой функции вместо прямой формулы целесообразно, поскольку ошибка намного меньше.  Нет недостатка с маленькими __x и __y.  Нет переполнения, если результат находится в диапазоне. 
  static int isfinite (double __x) 
  Функция isfinite () возвращает ненулевое значение, если __x конечно: не плюс или минус бесконечность и не NaN . 
  int isinf (двойной __x) 
  Функция isinf () возвращает 1, если аргумент __x является положительной бесконечностью, -1, если __x является отрицательной бесконечностью, и 0 в противном случае. 
  Примечание . GCC 4.3 может заменить эту функцию встроенным кодом, который возвращает значение 1 для обеих бесконечностей (ошибка gcc # 35509). 
  int isnan (двойной __x) 
  Функция isnan () возвращает 1, если аргумент __x представляет объект «не число» ( NaN ), иначе 0. 
  double ldexp (double __x, int __exp) 
  Функция ldexp () умножает число с плавающей запятой на целую степень 2. Она возвращает значение __x умноженное на 2, возведенное в степень __exp. 
  двойной журнал (двойной __x) 
  Функция log () возвращает натуральный логарифм аргумента __x. 
  двойной log10 (двойной __x) 
  Функция log10 () возвращает логарифм аргумента __x в основание 10. 
  длинный лринт (двойной __x) 
  Функция lrint () округляет __x до ближайшего целого, округляя полпути до четного целочисленного направления.  (То есть 1,5 и 2,5 значения округляются до 2).  Эта функция похожа на функцию rint (), но отличается по типу возвращаемого значения и тем, что возможно переполнение. 
  Возвращает 
  Округленное длинное целое значение.  Если __x не является конечным числом или переполнением, эта реализация возвращает значение LONG_MIN (0x80000000). 
  длинная земля (двойная __x) 
  Функция lround () округляет __x до ближайшего целого числа, но округляет значения на полпути от нуля (вместо ближайшего четного целого).  Эта функция похожа на функцию round (), но отличается по типу возвращаемого значения и тем, что возможно переполнение. 
  Возвращает 
  Округленное длинное целое значение.  Если __x не является конечным числом или было переполнение, эта реализация возвращает значение LONG_MIN (0x80000000). 
  двойной модф (двойной __x, двойной * __iptr) 
  Функция modf () разбивает аргумент __x на целые и дробные части, каждая из которых имеет тот же знак, что и аргумент.  Он хранит неотъемлемую часть как двойную в объекте, на который указывает __iptr. 
  Функция modf () возвращает дробную часть со знаком __x. 
  Примечание. Эта реализация пропускает запись по нулевому указателю.  Однако GCC 4.3 может заменить эту функцию встроенным кодом, который не позволяет использовать NULL-адрес для избежания сохранения. 
  float modff (float __x, float * __iptr) 
  Псевдоним для modf (). 
  двойной пау (двойной __x, двойной __y) 
  Функция pow () возвращает значение __x показателю __y. 
  двойной раунд (двойной __x) 
  Функция round () округляет __x до ближайшего целого числа, но округляет полпути до нуля (вместо ближайшего четного целого).  Переполнение невозможно. 
  Возвращает 
  Округленное значение.  Если __x является целым или бесконечным, возвращается сам __x.  Если __x равен NaN , то возвращается NaN . 
  int signbit (двойной __x) 
  Функция signbit () возвращает ненулевое значение, если значение __x имеет установленный знаковый бит.  Это не то же самое, что __x <0.0, потому что с плавающей точкой IEEE 754 позволяет подписать ноль.  Сравнение `-0.0 <0.0 'ложно, но` signbit (-0.0)' вернет ненулевое значение. 
  двойной грех (двойной __x) 
  Функция sin () возвращает синус __x, измеренный в радианах. 
  двойной синх (двойной __x) 
  Функция sinh () возвращает гиперболический синус __x. 
  двойной квадрат (двойной __x) 
  Функция sqrt () возвращает неотрицательный квадратный корень из __x. 
  двойной квадрат (двойной __x) 
  Функция square () возвращает __x * __x. 
  Примечание. Эта функция не относится к стандартному определению языка Си. 
  двойной загар (двойной __x) 
  Функция tan () возвращает тангенс __x, измеренный в радианах. 
  двойной танх (двойной __x) 
  Функция tanh () возвращает гиперболический тангенс __x. 
  двойное усечение (двойное __x) 
  Функция trunc () округляет __x до ближайшего целого числа, не большего по абсолютной величине. 
  пример 
  В следующем примере показано, как использовать наиболее распространенные функции библиотеки math.h: 
double double__x = 45.45 ;
double double__y = 30.20 ;

void setup() {
   Serial.begin(9600);
   Serial.print("cos num = ");
   Serial.println (cos (double__x) ); // returns cosine of x
   Serial.print("absolute value of num = ");
   Serial.println (fabs (double__x) ); // absolute value of a float
   Serial.print("floating point modulo = ");
   Serial.println (fmod (double__x, double__y)); // floating point modulo
   Serial.print("sine of num = ");
   Serial.println (sin (double__x) ) ;// returns sine of x
   Serial.print("square root of num : ");
   Serial.println ( sqrt (double__x) );// returns square root of x
   Serial.print("tangent of num : ");
   Serial.println ( tan (double__x) ); // returns tangent of x
   Serial.print("exponential value of num : ");
   Serial.println ( exp (double__x) ); // function returns the exponential value of x.
   Serial.print("cos num : ");

   Serial.println (atan (double__x) ); // arc tangent of x
   Serial.print("tangent of num : ");
   Serial.println (atan2 (double__y, double__x) );// arc tangent of y/x
   Serial.print("arc tangent of num : ");
   Serial.println (log (double__x) ) ; // natural logarithm of x
   Serial.print("cos num : ");
   Serial.println ( log10 (double__x)); // logarithm of x to base 10.
   Serial.print("logarithm of num to base 10 : ");
   Serial.println (pow (double__x, double__y) );// x to power of y
   Serial.print("power of num : ");
   Serial.println (square (double__x)); // square of x
}

void loop() {

}
  Результат 
cos num = 0.10
absolute value of num = 45.45
floating point modulo =15.25
sine of num = 0.99
square root of num : 6.74
tangent of num : 9.67
exponential value of num : ovf
cos num : 1.55
tangent of num : 0.59
arc tangent of num : 3.82
cos num : 1.66
logarithm of num to base 10 : inf
power of num : 2065.70

  Arduino - тригонометрические функции 
  Вы должны использовать тригонометрию практически как расчет расстояния для движущегося объекта или угловой скорости.  Arduino предоставляет традиционные тригонометрические функции (sin, cos, tan, asin, acos, atan), которые можно обобщить, написав свои прототипы.  Math.h содержит прототип функции тригонометрии. 
  Тригонометрический Точный Синтаксис 
double sin(double x); //returns sine of x radians
double cos(double y); //returns cosine of y radians
double tan(double x); //returns the tangent of x radians
double acos(double x); //returns A, the angle corresponding to cos (A) = x
double asin(double x); //returns A, the angle corresponding to sin (A) = x
double atan(double x); //returns A, the angle corresponding to tan (A) = x

  пример 
double sine = sin(2); // approximately 0.90929737091
double cosine = cos(2); // approximately -0.41614685058
double tangent = tan(2); // approximately -2.18503975868
  Arduino - Due & Zero 
  Arduino Due - это микроконтроллерная плата на базе процессора Atmel SAM3X8E ARM Cortex-M3.  Это первая плата Arduino, основанная на 32-разрядном ядре ARM. 
  Важные особенности - 

  Он имеет 54 цифровых входа / выхода (из которых 12 могут использоваться как выходы ШИМ) 
  12 аналоговых входов 
  4 UART (аппаратные последовательные порты) 
  Тактовая частота 84 МГц, соединение с поддержкой USB OTG 
  2 ЦАП (цифро-аналоговый), 2 TWI, разъем питания, разъем SPI, разъем JTAG 
  Кнопка сброса и кнопка стирания 


  Характеристики платы Arduino Due 



  Рабочее вольт 
  Скорость процессора 
  Аналоговый вход / выход 
  Цифровой IO / PWM 
  EEPROM [KB] 
  SRAM [KB] 
  Flash [КБ] 
  USB 
  УАПП 


  3,3 Вольт 
  84 МГц 
  12/2 
  54/12 
  - 
  96 
  512 
  2 микро 
  4 



  связь 

  4 аппаратных UART 
  2 I2C 
  1 интерфейс CAN (автомобильный протокол связи) 
  1 SPI 
  1 интерфейс JTAG (10-контактный) 
  1 USB Host (вроде как Леонардо) 
  1 порт программирования 

  В отличие от большинства плат Arduino, плата Arduino Due работает при напряжении 3,3 В.  Максимальное напряжение, которое могут выдержать контакты ввода / вывода, составляет 3,3 В.  Подача напряжения выше 3,3 В на любой вывод ввода-вывода может повредить плату. 
  Плата содержит все необходимое для поддержки микроконтроллера.  Вы можете просто подключить его к компьютеру с помощью кабеля micro-USB или включить адаптер переменного тока в постоянный ток или батарею, чтобы начать работу.  Due совместим со всеми экранами Arduino, работающими при напряжении 3,3 В. 
  Arduino Zero 
  Zero - это простое и мощное 32-разрядное расширение платформы, созданной ООН.  Плата Zero расширяет семейство, обеспечивая повышенную производительность, предоставляя разнообразные возможности для проектов для устройств, и служит отличным образовательным инструментом для изучения разработки 32-разрядных приложений. 
  Важные особенности - 


  Приложения Zero включают в себя интеллектуальные устройства IoT, носимые технологии, высокотехнологичную автоматизацию и безумную робототехнику. 


  Плата работает от микроконтроллера SAMD21 от Atmel с 32-разрядным ядром ARM Cortex® M0 +. 


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


  EDBG также поддерживает виртуальный COM-порт, который можно использовать для программирования устройства и загрузчика. 


  Приложения Zero включают в себя интеллектуальные устройства IoT, носимые технологии, высокотехнологичную автоматизацию и безумную робототехнику. 
  Плата работает от микроконтроллера SAMD21 от Atmel с 32-разрядным ядром ARM Cortex® M0 +. 
  Одной из наиболее важных функций является встроенный отладчик Atmel (EDBG), который обеспечивает полный интерфейс отладки без необходимости в дополнительном оборудовании, что значительно повышает удобство использования для отладки программного обеспечения. 
  EDBG также поддерживает виртуальный COM-порт, который можно использовать для программирования устройства и загрузчика. 

  Характеристики платы Arduino Zero 



  Рабочее вольт 
  Скорость процессора 
  Аналоговый вход / выход 
  Цифровой IO / PWM 
  EEPROM [KB] 
  SRAM [KB] 
  Flash [КБ] 
  USB 
  УАПП 


  3,3 Вольт 
  48 МГц 
  6/1 
  14/10 
  - 
  32 
  256 
  2 микро 
  2 



  В отличие от большинства плат Arduino и Genuino, Zero работает при напряжении 3,3 В.  Максимальное напряжение, которое могут выдержать контакты ввода / вывода, составляет 3,3 В.  Подача напряжения выше 3,3 В на любой вывод ввода-вывода может повредить плату. 
  Плата содержит все необходимое для поддержки микроконтроллера.  Вы можете просто подключить его к компьютеру с помощью кабеля micro-USB или включить адаптер переменного тока в постоянный ток или батарею, чтобы начать работу.  Ноль совместим со всеми экранами, которые работают при 3,3 В. 
  Arduino - широтно-импульсная модуляция 
  Широтно-импульсная модуляция или ШИМ - это распространенный метод, используемый для изменения ширины импульсов в последовательности импульсов.  ШИМ имеет много применений, таких как управление сервоприводами и регуляторами скорости, ограничивая эффективную мощность двигателей и светодиодов. 
  Основной принцип ШИМ 
  Широтно-импульсная модуляция в основном представляет собой прямоугольную волну с переменным высоким и низким временем.  Базовый сигнал ШИМ показан на следующем рисунке. 

  Существуют различные термины, связанные с ШИМ - 


  On-Time - длительность сигнала времени высокая. 


  Off-Time - длительность сигнала времени низкая. 


  Период - представляет собой сумму времени включения и выключения сигнала ШИМ. 


  Рабочий цикл - Он представлен в процентах от времени, которое остается включенным в течение периода сигнала ШИМ. 


  On-Time - длительность сигнала времени высокая. 
  Off-Time - длительность сигнала времени низкая. 
  Период - представляет собой сумму времени включения и выключения сигнала ШИМ. 
  Рабочий цикл - Он представлен в процентах от времени, которое остается включенным в течение периода сигнала ШИМ. 
  период 
  Как показано на рисунке, T on обозначает время включения, а T off обозначает время выключения сигнала.  Период представляет собой сумму времени включения и выключения и рассчитывается, как показано в следующем уравнении: 
  $$ T_ {total} = T_ {on} + T_ {off} $$ 
  Рабочий цикл 
  Рабочий цикл рассчитывается как время включения периода времени.  Используя рассчитанный выше период, рабочий цикл рассчитывается как - 
  $$ D = \ frac {T_ {on}} {T_ {on} + T_ {off}} = \ frac {T_ {on}} {T_ {total}} $$ 
  функция analogWrite () 
  Функция analogWrite () записывает аналоговое значение (волна ШИМ) на вывод.  Его можно использовать для подсветки светодиода с разной яркостью или для привода двигателя на разных скоростях.  После вызова функции analogWrite () вывод будет генерировать устойчивую прямоугольную волну указанного рабочего цикла до следующего вызова аналогаWrite () или вызова digitalRead () или digitalWrite () на том же выводе.  Частота ШИМ-сигнала на большинстве контактов составляет приблизительно 490 Гц.  На платах Uno и аналогичных платах контакты 5 и 6 имеют частоту приблизительно 980 Гц.  Контакты 3 и 11 на Leonardo также работают на частоте 980 Гц. 
  На большинстве плат Arduino (с платами ATmega168 или ATmega328) эта функция работает на контактах 3, 5, 6, 9, 10 и 11. На плате Arduino Mega она работает на контактах 2–13 и 44–46. Старая версия Arduino Платы с ATmega8 поддерживают аналоговыйWrite () только на контактах 9, 10 и 11. 

  Arduino Due поддерживает analogWrite () на контактах 2–13 и контактах DAC0 и DAC1.  В отличие от выводов PWM, DAC0 и DAC1 являются цифро-аналоговыми преобразователями и действуют как настоящие аналоговые выходы. 
  Вам не нужно вызывать pinMode (), чтобы установить вывод в качестве выхода перед вызовом analogWrite (). 
  analogWrite () Синтаксис функции 
analogWrite ( pin , value ) ;

  значение - коэффициент заполнения: от 0 (всегда выключен) до 255 (всегда включен). 
  пример 
int ledPin = 9; // LED connected to digital pin 9
int analogPin = 3; // potentiometer connected to analog pin 3
int val = 0; // variable to store the read value

void setup() {
   pinMode(ledPin, OUTPUT); // sets the pin as output
}

void loop() {
   val = analogRead(analogPin); // read the input pin
   analogWrite(ledPin, (val / 4)); // analogRead values go from 0 to 1023, 
      // analogWrite values from 0 to 255
}
  Arduino - случайные числа 
  Для генерации случайных чисел вы можете использовать функции случайных чисел Arduino.  У нас есть две функции - 

  randomSeed (семена) 
  случайным образом () 

  randomSeed (семя) 
  Функция randomSeed (seed) сбрасывает генератор псевдослучайных чисел в Arduino.  Хотя распределение чисел, возвращаемых random (), по сути случайное, последовательность предсказуема.  Вы должны сбросить генератор к некоторому случайному значению.  Если у вас есть неподключенный аналоговый вывод, он может воспринимать случайный шум из окружающей среды.  Это могут быть радиоволны, космические лучи, электромагнитные помехи от сотовых телефонов, флуоресцентные лампы и так далее. 
  пример 
randomSeed(analogRead(5)); // randomize using noise from analog pin 5
  случайный () 
  Случайная функция генерирует псевдослучайные числа.  Ниже приводится синтаксис. 
  random () Синтаксис операторов 
long random(max) // it generate random numbers from 0 to max
long random(min, max) // it generate random numbers from min to max

  пример 
long randNumber;

void setup() {
   Serial.begin(9600);
   // if analog input pin 0 is unconnected, random analog
   // noise will cause the call to randomSeed() to generate
   // different seed numbers each time the sketch runs.
   // randomSeed() will then shuffle the random function.
   randomSeed(analogRead(0));
}

void loop() {
   // print a random number from 0 to 299
   Serial.print("random1=");
   randNumber = random(300);
   Serial.println(randNumber); // print a random number from 0to 299
   Serial.print("random2=");
   randNumber = random(10, 20);// print a random number from 10 to 19
   Serial.println (randNumber);
   delay(50);
}
  Давайте теперь освежим наши знания о некоторых основных понятиях, таких как биты и байты. 
  Биты 
  Бит это просто двоичная цифра. 


  Двоичная система использует две цифры, 0 и 1. 


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


  Двоичная система использует две цифры, 0 и 1. 
  Подобно десятичной системе счисления, в которой цифры числа не имеют одно и то же значение, «значимость» бита зависит от его положения в двоичном числе.  Например, цифры в десятичном числе 666 одинаковы, но имеют разные значения. 

  Б 
  Байт состоит из восьми битов. 


  Если бит является цифрой, логично, что байты представляют числа. 


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


  Цифры в байте также не имеют одинакового значения. 


  Крайний левый бит имеет наибольшее значение, называемое старшим битом (MSB). 


  Самый правый бит имеет наименьшее значение и поэтому называется наименьшим значащим битом (LSB). 


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


  Если бит является цифрой, логично, что байты представляют числа. 
  Все математические операции могут быть выполнены на них. 
  Цифры в байте также не имеют одинакового значения. 
  Крайний левый бит имеет наибольшее значение, называемое старшим битом (MSB). 
  Самый правый бит имеет наименьшее значение и поэтому называется наименьшим значащим битом (LSB). 
  Поскольку восемь нулей и единиц одного байта могут быть объединены 256 различными способами, наибольшее десятичное число, которое может быть представлено одним байтом, равно 255 (одна комбинация представляет ноль). 
  Arduino - Прерывания 
  Прерывания останавливают текущую работу Arduino, так что может быть выполнена другая работа. 
  Предположим, вы сидите дома, общаетесь с кем-то.  Внезапно зазвонил телефон.  Вы прекращаете общаться и берете трубку, чтобы поговорить с абонентом.  Когда вы закончите разговор по телефону, вы вернетесь к разговору с человеком до того, как зазвонит телефон. 
  Точно так же вы можете думать об основной процедуре как о чата с кем-то, телефонный звонок заставляет вас перестать общаться.  Процедура обслуживания прерывания - это процесс разговора по телефону.  Когда телефонный разговор заканчивается, вы возвращаетесь к своей основной рутине общения.  Этот пример объясняет, как именно прерывание заставляет процессор работать. 
  Основная программа работает и выполняет некоторую функцию в цепи.  Однако, когда происходит прерывание, основная программа останавливается, пока выполняется другая процедура.  Когда эта процедура заканчивается, процессор снова возвращается к основной процедуре. 

  Важные особенности 
  Вот несколько важных особенностей о прерываниях - 


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


  Большинство конструкций Arduino имеют два аппаратных прерывания (называемые «прерывание 0» и «прерывание 1»), жестко соединенные с выводами цифрового ввода-вывода 2 и 3 соответственно. 


  Arduino Mega имеет шесть аппаратных прерываний, включая дополнительные прерывания («interrupt2» - «interrupt5») на контактах 21, 20, 19 и 18. 


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


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


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


  Прерывания могут исходить из разных источников.  В этом случае мы используем аппаратное прерывание, которое вызывается изменением состояния на одном из цифровых выводов. 
  Большинство конструкций Arduino имеют два аппаратных прерывания (называемые «прерывание 0» и «прерывание 1»), жестко соединенные с выводами цифрового ввода-вывода 2 и 3 соответственно. 
  Arduino Mega имеет шесть аппаратных прерываний, включая дополнительные прерывания («interrupt2» - «interrupt5») на контактах 21, 20, 19 и 18. 
  Вы можете определить подпрограмму, используя специальную функцию, называемую «подпрограмма обработки прерывания» (обычно известная как ISR). 
  Вы можете определить процедуру и указать условия на переднем или заднем фронте или на обоих.  В этих конкретных условиях прерывание будет обслуживаться. 
  Эту функцию можно выполнить автоматически каждый раз, когда происходит событие на входном выводе. 
  Типы прерываний 
  Есть два типа прерываний - 


  Аппаратные прерывания - они происходят в ответ на внешнее событие, такое как вывод внешнего прерывания, повышающийся или понижающийся. 


  Программные прерывания - они происходят в ответ на инструкцию, отправленную в программном обеспечении.  Единственный тип прерывания, который поддерживает «язык Arduino», - это функция attachInterrupt (). 


  Аппаратные прерывания - они происходят в ответ на внешнее событие, такое как вывод внешнего прерывания, повышающийся или понижающийся. 
  Программные прерывания - они происходят в ответ на инструкцию, отправленную в программном обеспечении.  Единственный тип прерывания, который поддерживает «язык Arduino», - это функция attachInterrupt (). 
  Использование прерываний в Arduino 
  Прерывания очень полезны в программах Arduino, так как они помогают в решении проблем синхронизации.  Хорошее применение прерывания - это чтение вращающегося датчика или наблюдение за пользовательским вводом.  Как правило, ISR должен быть максимально коротким и быстрым.  Если ваш эскиз использует несколько ISR, одновременно может выполняться только один.  Другие прерывания будут выполнены после того, как текущее прерывание завершится в порядке, который зависит от их приоритета. 
  Как правило, глобальные переменные используются для передачи данных между ISR и основной программой.  Чтобы убедиться, что переменные, общие для ISR и основной программы, обновлены правильно, объявите их как volatile. 
  Синтаксис оператора attachInterrupt 
attachInterrupt(digitalPinToInterrupt(pin),ISR,mode);//recommended for arduino board
attachInterrupt(pin, ISR, mode) ; //recommended Arduino Due, Zero only
//argument pin: the pin number
//argument ISR: the ISR to call when the interrupt occurs; 
   //this function must take no parameters and return nothing. 
   //This function is sometimes referred to as an interrupt service routine.
//argument mode: defines when the interrupt should be triggered.

  Следующие три константы предопределены как допустимые значения - 


  НИЗКИЙ, чтобы вызвать прерывание всякий раз, когда вывод низкий. 


  ИЗМЕНИТЬ, чтобы вызвать прерывание всякий раз, когда вывод меняет значение. 


  Падение всякий раз, когда штифт идет от высокой к низкой. 


  НИЗКИЙ, чтобы вызвать прерывание всякий раз, когда вывод низкий. 
  ИЗМЕНИТЬ, чтобы вызвать прерывание всякий раз, когда вывод меняет значение. 
  Падение всякий раз, когда штифт идет от высокой к низкой. 
  пример 
int pin = 2; //define interrupt pin to 2
volatile int state = LOW; // To make sure variables shared between an ISR
//the main program are updated correctly,declare them as volatile.

void setup() {
   pinMode(13, OUTPUT); //set pin 13 as output
   attachInterrupt(digitalPinToInterrupt(pin), blink, CHANGE);
   //interrupt at pin 2 blink ISR when pin to change the value
} 
void loop() { 
   digitalWrite(13, state); //pin 13 equal the state value
} 

void blink() { 
   //ISR function
   state = !state; //toggle the state when the interrupt occurs
}
  Arduino - Связь 
  Для обмена данными были определены сотни протоколов связи.  Каждый протокол можно разделить на две категории: параллельный или последовательный. 
  Параллельное общение 
  Параллельное соединение между Arduino и периферийными устройствами через порты ввода / вывода является идеальным решением для коротких расстояний до нескольких метров.  Однако в других случаях, когда необходимо установить связь между двумя устройствами на большие расстояния, невозможно использовать параллельное соединение.  Параллельные интерфейсы передают несколько битов одновременно.  Они обычно требуют шины данных - передача по восьми, шестнадцати или более проводам.  Данные передаются огромными, падающими волнами 1 и 0. 

  Преимущества и недостатки параллельной коммуникации 
  Параллельное общение, безусловно, имеет свои преимущества.  Это быстрее, чем последовательный, простой и относительно простой в реализации.  Однако, это требует много портов ввода / вывода (I / O) и линий.  Если вам когда-либо приходилось перемещать проект с базового Arduino Uno на Mega, вы знаете, что линии ввода / вывода на микропроцессоре могут быть очень ценными и их мало.  Поэтому мы предпочитаем последовательную связь, жертвуя потенциальной скоростью для недвижимости. 
  Модули последовательной связи 
  Сегодня большинство плат Arduino оснащаются несколькими различными системами последовательной связи в качестве стандартного оборудования. 
  Какая из этих систем используется, зависит от следующих факторов: 

  С сколькими устройствами микроконтроллер должен обмениваться данными? 
  Насколько быстрым должен быть обмен данными? 
  Каково расстояние между этими устройствами? 
  Нужно ли отправлять и получать данные одновременно? 

  Одной из самых важных вещей, касающихся последовательной связи, является протокол , который должен строго соблюдаться.  Это набор правил, которые должны применяться таким образом, чтобы устройства могли правильно интерпретировать данные, которыми они обмениваются друг с другом.  К счастью, Arduino автоматически позаботится об этом, так что работа программиста / пользователя сводится к простой записи (данные, которые будут отправлены) и чтению (полученные данные). 
  Типы последовательных коммуникаций 
  Последовательная связь может быть далее классифицирована как - 


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


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


  Синхронный - устройства, которые синхронизируются, используют одни и те же часы, и их синхронизация синхронизируется друг с другом. 
  Асинхронный - асинхронные устройства имеют свои собственные часы и запускаются выходным сигналом предыдущего состояния. 
  Легко узнать, является ли устройство синхронным или нет.  Если одинаковые часы выдаются всем подключенным устройствам, то они являются синхронными.  Если нет тактовой линии, она асинхронная. 
  Например, модуль UART (универсальный асинхронный приемник-передатчик) является асинхронным. 
  Асинхронный последовательный протокол имеет ряд встроенных правил.  Эти правила - не что иное, как механизмы, которые помогают обеспечить надежную и безошибочную передачу данных.  Эти механизмы, которые мы получаем для избежания внешнего тактового сигнала, - 

  Биты синхронизации 
  Биты данных 
  Биты четности 
  Скорость передачи 

  Биты синхронизации 
  Биты синхронизации - это два или три специальных бита, передаваемых с каждым пакетом данных.  Это стартовый бит и стоповый бит (ы).  В соответствии со своим именем эти биты отмечают начало и конец пакета соответственно. 
  Всегда есть только один стартовый бит, но число стоповых битов можно настроить на один или два (хотя обычно он остается равным одному). 
  Стартовый бит всегда указывается незанятой линией данных, идущей от 1 до 0, в то время как стоповый бит (биты) переходит обратно в состояние ожидания, удерживая строку в 1. 

  Биты данных 
  Количество данных в каждом пакете может быть установлено на любой размер от 5 до 9 бит.  Конечно, стандартный размер данных - это ваш базовый 8-битный байт, но другие размеры имеют свое применение.  7-битный пакет данных может быть более эффективным, чем 8, особенно если вы просто передаете 7-битные символы ASCII. 
  Биты четности 
  Пользователь может выбрать, должен ли быть бит четности или нет, и если да, должен ли четность быть нечетным или четным.  Бит четности равен 0, если число единиц среди битов данных является четным.  Странный паритет как раз наоборот. 
  Скорость передачи 
  Термин скорость передачи данных используется для обозначения количества битов, передаваемых в секунду [бит / с].  Обратите внимание, что это относится к битам, а не байтов.  Протокол обычно требует, чтобы каждый байт передавался вместе с несколькими управляющими битами.  Это означает, что один байт в последовательном потоке данных может состоять из 11 битов.  Например, если скорость передачи составляет 300 бит / с, то в секунду могут передаваться максимум 37 и минимум 27 байтов. 
  Arduino UART 
  Следующий код заставит Arduino отправить привет миру, когда он запустится. 
void setup() {
   Serial.begin(9600); //set up serial library baud rate to 9600
   Serial.println("hello world"); //print hello world
}

void loop() {

}
  После загрузки эскиза Arduino в Arduino откройте монитор Serial.   в правом верхнем углу Arduino IDE. 
  Введите что-нибудь в верхнюю часть последовательного монитора и нажмите отправить или войти на клавиатуре.  Это отправит серию байтов в Arduino. 
  Следующий код возвращает все, что он получает в качестве ввода. 
  Следующий код заставит Arduino доставлять вывод в зависимости от предоставленного ввода. 
void setup() {
   Serial.begin(9600); //set up serial library baud rate to 9600
}

void loop() {
   if(Serial.available()) //if number of bytes (characters) available for reading from { 
      serial port
      Serial.print("I received:"); //print I received
      Serial.write(Serial.read()); //send what you read
   }
}
  Обратите внимание, что Serial.print и Serial.println отправят обратно фактический код ASCII, тогда как Serial.write отправит обратно фактический текст.  См. ASCII коды для получения дополнительной информации. 
  Arduino - Интегральная микросхема 
  Межинтегральная схема (I2C) представляет собой систему последовательного обмена данными между микроконтроллерами и специализированными интегральными схемами нового поколения.  Он используется, когда расстояние между ними небольшое (приемник и передатчик обычно находятся на одной печатной плате).  Соединение устанавливается через два проводника.  Один используется для передачи данных, а другой - для синхронизации (тактовый сигнал). 
  Как видно на следующем рисунке, одно устройство всегда является мастером.  Он выполняет адресацию одного ведомого чипа до начала связи.  Таким образом, один микроконтроллер может связываться со 112 различными устройствами.  Скорость передачи данных обычно составляет 100 кбит / с (стандартный режим) или 10 кбит / с (режим медленной скорости).  Недавно появились системы со скоростью передачи 3,4 Мбит / с.  Расстояние между устройствами, связывающимися по шине I2C, ограничено несколькими метрами. 

  Плата I2C Pins 
  Шина I2C состоит из двух сигналов - SCL и SDA.  SCL - это тактовый сигнал, а SDA - это сигнал данных.  Текущий мастер шины всегда генерирует тактовый сигнал.  Некоторые ведомые устройства могут время от времени приводить к снижению тактового сигнала, чтобы задержать передачу мастером большего количества данных (или требовать больше времени для подготовки данных, прежде чем мастер попытается отключить их).  Это известно как «растяжение часов». 
  Ниже приведены выводы для различных плат Arduino - 

  Uno, Pro Mini A4 (SDA), A5 (SCL) 
  Mega, Due 20 (SDA), 21 (SCL) 
  Леонардо, Юн 2 (SDA), 3 (SCL) 

  Arduino I2C 
  У нас есть два режима - мастер-код и подчиненный код - для подключения двух плат Arduino с использованием I2C.  Они - 

  Главный передатчик / ведомый приемник 
  Главный приемник / ведомый передатчик 

  Главный передатчик / ведомый приемник 
  Давайте теперь посмотрим, что такое главный передатчик и подчиненный приемник. 
  Мастер передатчик 
  Следующие функции используются для инициализации библиотеки проводов и подключения шины I2C в качестве главного или подчиненного.  Обычно это называется только один раз. 


  Wire.begin (адрес) - Адрес - это 7-битный адрес ведомого в нашем случае, так как мастер не указан, и он присоединится к шине как мастер. 


  Wire.beginTransmission (address) - начать передачу на ведомое устройство I2C с заданным адресом. 


  Wire.write (значение) - ставит байты в очередь для передачи от ведущего устройства к ведомому (промежуточные вызовы функций beginTransmission () и endTransmission ()). 


  Wire.endTransmission () - Завершает передачу на подчиненное устройство, которая была начата методом beginTransmission (), и передает байты, которые были поставлены в очередь wire.write (). 


  Wire.begin (адрес) - Адрес - это 7-битный адрес ведомого в нашем случае, так как мастер не указан, и он присоединится к шине как мастер. 
  Wire.beginTransmission (address) - начать передачу на ведомое устройство I2C с заданным адресом. 
  Wire.write (значение) - ставит байты в очередь для передачи от ведущего устройства к ведомому (промежуточные вызовы функций beginTransmission () и endTransmission ()). 
  Wire.endTransmission () - Завершает передачу на подчиненное устройство, которая была начата методом beginTransmission (), и передает байты, которые были поставлены в очередь wire.write (). 
  пример 
#include <Wire.h> //include wire library

void setup() //this will run only once { 
   Wire.begin(); // join i2c bus as master
} 

short age = 0; 

void loop() {   
   Wire.beginTransmission(2); 
   // transmit to device #2
   Wire.write("age is = ");
   Wire.write(age); // sends one byte
   Wire.endTransmission(); // stop transmitting
   delay(1000); 
}
  Раб приемник 
  Используются следующие функции - 


  Wire.begin (адрес) - Адрес является 7-битным адресом подчиненного устройства. 


  Wire.onReceive (обработчик полученных данных) - функция, которая вызывается, когда подчиненное устройство получает данные от ведущего. 


  Wire.available () - возвращает количество байтов, доступных для извлечения с помощью Wire.read (). Это следует вызывать в обработчике Wire.onReceive (). 


  Wire.begin (адрес) - Адрес является 7-битным адресом подчиненного устройства. 
  Wire.onReceive (обработчик полученных данных) - функция, которая вызывается, когда подчиненное устройство получает данные от ведущего. 
  Wire.available () - возвращает количество байтов, доступных для извлечения с помощью Wire.read (). Это следует вызывать в обработчике Wire.onReceive (). 
  пример 
#include <Wire.h> //include wire library

void setup() {  //this will run only once
   Wire.begin(2); // join i2c bus with address #2
   Wire.onReceive(receiveEvent); // call receiveEvent when the master send any thing 
   Serial.begin(9600); // start serial for output to print what we receive 
}

void loop() {   
   delay(250); 
}

//-----this function will execute whenever data is received from master-----//

void receiveEvent(int howMany) { 
   while (Wire.available()>1) // loop through all but the last {
      char c = Wire.read(); // receive byte as a character
      Serial.print(c); // print the character
   }
}
  Главный приемник / ведомый передатчик 
  Давайте теперь посмотрим, что такое главный приемник и подчиненный передатчик. 
  Мастер приемник 
  Мастер запрограммирован на запрос, а затем считывает байты данных, которые отправляются от подчиненного устройства Arduino с уникальным адресом. 
  Следующая функция используется - 
  Wire.requestFrom (адрес, количество байтов) - используется ведущим для запроса байтов от подчиненного устройства.  Затем байты могут быть получены с помощью функций wire.available () и wire.read (). 
  пример 
#include <Wire.h> //include wire library void setup() { 
   Wire.begin(); // join i2c bus (address optional for master) 
   Serial.begin(9600); // start serial for output
} 

void loop() { 
   Wire.requestFrom(2, 1); // request 1 bytes from slave device #2
   while (Wire.available()) // slave may send less than requested {
      char c = Wire.read(); // receive a byte as character
      Serial.print(c); // print the character
   } 
   delay(500); 
}
  Раб передатчик 
  Следующая функция используется. 
  Wire.onRequest (обработчик) - функция вызывается, когда мастер запрашивает данные с этого подчиненного устройства. 
  пример 
#include <Wire.h> 

void setup() { 
   Wire.begin(2); // join i2c bus with address #2
   Wire.onRequest(requestEvent); // register event
} 

Byte x = 0;

void loop() { 
   delay(100); 
} 

// function that executes whenever data is requested by master
// this function is registered as an event, see setup()

void requestEvent() { 
   Wire.write(x); // respond with message of 1 bytes as expected by master
   x++; 
}
  Arduino - последовательный периферийный интерфейс 
  Шина последовательного периферийного интерфейса (SPI) - это система для последовательной связи, которая использует до четырех проводников, обычно три.  Один проводник используется для приема данных, один для отправки данных, один для синхронизации и один альтернативно для выбора устройства для связи.  Это полнодуплексное соединение, что означает, что данные отправляются и принимаются одновременно.  Максимальная скорость передачи выше, чем в системе связи I2C. 
  Board SPI Pins 
  SPI использует следующие четыре провода - 


  SCK - это последовательные часы, управляемые мастером. 


  MOSI - это главный выход / ведомый вход, управляемый ведущим. 


  MISO - это главный вход / выход ведомого, управляемый ведущим. 


  SS - это ведомый выбор. 


  SCK - это последовательные часы, управляемые мастером. 
  MOSI - это главный выход / ведомый вход, управляемый ведущим. 
  MISO - это главный вход / выход ведомого, управляемый ведущим. 
  SS - это ведомый выбор. 
  Используются следующие функции.  Вы должны включить SPI.h. 


  SPI.begin () - Инициализирует шину SPI, устанавливая SCK, MOSI и SS на выходы, подтягивая SCK и MOSI на низкий и SS на высокий. 


  SPI.setClockDivider (divider) - установить делитель тактового сигнала SPI относительно системных часов.  На платах, основанных на AVR, доступны делители 2, 4, 8, 16, 32, 64 или 128. Значение по умолчанию - SPI_CLOCK_DIV4, которое устанавливает тактовую частоту SPI на одну четверть частоты системной тактовой частоты (5 МГц для платы на 20 МГц). 


  Разделитель - это может быть (SPI_CLOCK_DIV2, SPI_CLOCK_DIV4, SPI_CLOCK_DIV8, SPI_CLOCK_DIV16, SPI_CLOCK_DIV32, SPI_CLOCK_DIV64, SPI_CLOCK_DIV128). 


  SPI.transfer (val) - передача SPI основана на одновременной отправке и получении: полученные данные возвращаются в receiveVal. 


  SPI.beginTransaction (SPISettings (speedMaximum, dataOrder, dataMode)) - speedMaximum - это часы, dataOrder (MSBFIRST или LSBFIRST), dataMode (SPI_MODE0, SPI_MODE1, SPI_MODE2 или SPI_MODE3). 


  SPI.begin () - Инициализирует шину SPI, устанавливая SCK, MOSI и SS на выходы, подтягивая SCK и MOSI на низкий и SS на высокий. 
  SPI.setClockDivider (divider) - установить делитель тактового сигнала SPI относительно системных часов.  На платах, основанных на AVR, доступны делители 2, 4, 8, 16, 32, 64 или 128. Значение по умолчанию - SPI_CLOCK_DIV4, которое устанавливает тактовую частоту SPI на одну четверть частоты системной тактовой частоты (5 МГц для платы на 20 МГц). 
  Разделитель - это может быть (SPI_CLOCK_DIV2, SPI_CLOCK_DIV4, SPI_CLOCK_DIV8, SPI_CLOCK_DIV16, SPI_CLOCK_DIV32, SPI_CLOCK_DIV64, SPI_CLOCK_DIV128). 
  SPI.transfer (val) - передача SPI основана на одновременной отправке и получении: полученные данные возвращаются в receiveVal. 
  SPI.beginTransaction (SPISettings (speedMaximum, dataOrder, dataMode)) - speedMaximum - это часы, dataOrder (MSBFIRST или LSBFIRST), dataMode (SPI_MODE0, SPI_MODE1, SPI_MODE2 или SPI_MODE3). 
  У нас есть четыре режима работы в SPI: 


  Режим 0 (по умолчанию) - Часы обычно имеют низкий уровень (CPOL = 0), и данные выбираются при переходе от низкого к высокому (передний фронт) (CPHA = 0). 


  Режим 1 - тактовая частота обычно низкая (CPOL = 0), и данные выбираются при переходе от высокого к низкому (задний фронт) (CPHA = 1). 


  Режим 2 - тактовая частота обычно высокая (CPOL = 1), и данные выбираются при переходе от высокого к низкому (передний фронт) (CPHA = 0). 


  Режим 3 - тактовая частота обычно высокая (CPOL = 1), и данные выбираются при переходе от низкого к высокому (задний фронт) (CPHA = 1). 


  SPI.attachInterrupt (handler) - функция, которая вызывается, когда подчиненное устройство получает данные от ведущего. 


  Режим 0 (по умолчанию) - Часы обычно имеют низкий уровень (CPOL = 0), и данные выбираются при переходе от низкого к высокому (передний фронт) (CPHA = 0). 
  Режим 1 - тактовая частота обычно низкая (CPOL = 0), и данные выбираются при переходе от высокого к низкому (задний фронт) (CPHA = 1). 
  Режим 2 - тактовая частота обычно высокая (CPOL = 1), и данные выбираются при переходе от высокого к низкому (передний фронт) (CPHA = 0). 
  Режим 3 - тактовая частота обычно высокая (CPOL = 1), и данные выбираются при переходе от низкого к высокому (задний фронт) (CPHA = 1). 
  SPI.attachInterrupt (handler) - функция, которая вызывается, когда подчиненное устройство получает данные от ведущего. 
  Теперь мы соединяем две платы Arduino UNO вместе;  один как хозяин, а другой как раб. 

  (SS): контакт 10 
  (MOSI): контакт 11 
  (MISO): контакт 12 
  (SCK): контакт 13 

  Земля общая.  Ниже приведено схематическое изображение соединения между двумя платами: 

  Давайте посмотрим на примеры SPI как Master и SPI как Slave. 
  SPI как МАСТЕР 
  пример 
#include <SPI.h>

void setup (void) {
   Serial.begin(115200); //set baud rate to 115200 for usart
   digitalWrite(SS, HIGH); // disable Slave Select
   SPI.begin ();
   SPI.setClockDivider(SPI_CLOCK_DIV8);//divide the clock by 8
}

void loop (void) {
   char c;
   digitalWrite(SS, LOW); // enable Slave Select
   // send test string
   for (const char * p = "Hello, world!\r" ; c = *p; p++) {
      SPI.transfer (c);
      Serial.print(c);
   }
   digitalWrite(SS, HIGH); // disable Slave Select
   delay(2000);
}
  SPI как РАБ 
  пример 
#include <SPI.h>
char buff [50];
volatile byte indx;
volatile boolean process;

void setup (void) {
   Serial.begin (115200);
   pinMode(MISO, OUTPUT); // have to send on master in so it set as output
   SPCR |= _BV(SPE); // turn on SPI in slave mode
   indx = 0; // buffer empty
   process = false;
   SPI.attachInterrupt(); // turn on interrupt
}
ISR (SPI_STC_vect) // SPI interrupt routine { 
   byte c = SPDR; // read byte from SPI Data Register
   if (indx < sizeof buff) {
      buff [indx++] = c; // save data in the next index in the array buff
      if (c == '\r') //check for the end of the word
      process = true;
   }
}

void loop (void) {
   if (process) {
      process = false; //reset the process
      Serial.println (buff); //print the array on serial monitor
      indx= 0; //reset button to zero
   }
}
  Arduino - мигающий светодиод 
  Светодиоды - это маленькие мощные лампы, которые используются во многих различных приложениях.  Для начала мы будем мигать светодиодом Hello World из микроконтроллеров.  Это так же просто, как включить и выключить свет.  Установление этой важной базовой линии даст вам прочную основу, поскольку мы работаем над более сложными экспериментами. 
  Необходимые компоненты 
  Вам понадобятся следующие компоненты - 

  1 × макет 
  1 × Arduino Uno R3 
  1 × светодиод 
  Резистор 1 × 330 Ом 
  2 × джемпер 

  Процедура 
  Следуйте электрической схеме и подключите компоненты на макете, как показано на рисунке ниже. 

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

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

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

  Arduino Code 
/*
   Blink
   Turns on an LED on for one second, then off for one second, repeatedly.
*/

// the setup function runs once when you press reset or power the board

void setup() {  // initialize digital pin 13 as an output.
   pinMode(2, OUTPUT);
}

// the loop function runs over and over again forever

void loop() {
   digitalWrite(2, HIGH); // turn the LED on (HIGH is the voltage level)
   delay(1000); // wait for a second
   digitalWrite(2, LOW); // turn the LED off by making the voltage LOW
   delay(1000); // wait for a second
}
  Код для заметки 
  pinMode (2, OUTPUT) - Прежде чем вы сможете использовать один из выводов Arduino, вы должны сообщить Arduino Uno R3, является ли он INPUT или OUTPUT.  Для этого мы используем встроенную «функцию», называемую pinMode (). 
  digitalWrite (2, HIGH) - когда вы используете вывод в качестве ВЫХОДА, вы можете задать ему значение HIGH (выход 5 вольт) или LOW (выход 0 вольт). 
  Результат 
  Вы должны увидеть, как ваш светодиод включается и выключается.  Если требуемый выходной сигнал не виден, убедитесь, что вы правильно собрали схему, проверили и загрузили код на свою плату. 
  Arduino - гаснет светодиод 
  Этот пример демонстрирует использование функции analogWrite () при отключении светодиода.  AnalogWrite использует широтно-импульсную модуляцию (ШИМ), очень быстро включая и выключая цифровой вывод с различными соотношениями между включением и выключением, чтобы создать эффект затухания. 
  Необходимые компоненты 
  Вам понадобятся следующие компоненты - 

  1 × макет 
  1 × Arduino Uno R3 
  1 × светодиод 
  Резистор 1 × 330 Ом 
  2 × джемпер 

  Процедура 
  Следуйте электрической схеме и подключите компоненты на макете, как показано на рисунке ниже. 

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

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

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

  Arduino Code 
/*
   Fade
   This example shows how to fade an LED on pin 9 using the analogWrite() function.

   The analogWrite() function uses PWM, so if you want to change the pin you're using, be
   sure to use another PWM capable pin. On most Arduino, the PWM pins are identified with
   a "~" sign, like ~3, ~5, ~6, ~9, ~10 and ~11.
*/

int led = 9; // the PWM pin the LED is attached to
int brightness = 0; // how bright the LED is
int fadeAmount = 5; // how many points to fade the LED by
// the setup routine runs once when you press reset:

void setup() {
   // declare pin 9 to be an output:
   pinMode(led, OUTPUT);
}

// the loop routine runs over and over again forever:

void loop() {
   // set the brightness of pin 9:
   analogWrite(led, brightness);
   // change the brightness for next time through the loop:
   brightness = brightness + fadeAmount;
   // reverse the direction of the fading at the ends of the fade:
   if (brightness == 0 || brightness == 255) {
      fadeAmount = -fadeAmount ;
   }
   // wait for 30 milliseconds to see the dimming effect
   delay(300);
}
  Код для заметки 
  После объявления вывода 9 в качестве вывода светодиода ничего не нужно делать в функции setup () вашего кода.  Функция analogWrite (), которую вы будете использовать в главном цикле вашего кода, требует двух аргументов: один, сообщающий функции, на какой контакт выводить запись, и другой, указывающий, какое значение ШИМ необходимо записать. 
  Для того чтобы светодиод погас и выключался, постепенно увеличивайте значения ШИМ с 0 (полностью выключенный) до 255 (полностью включенный), а затем возвращайтесь к 0, чтобы завершить цикл.  В приведенном выше наброске значение ШИМ установлено с помощью переменной, называемой яркостью.  Каждый раз в цикле он увеличивается на значение переменной fadeAmount . 
  Если яркость находится на пределе своего значения (0 или 255), то fadeAmount изменяется на отрицательный.  Другими словами, если fadeAmount равен 5, то он равен -5.  Если оно равно -5, то оно установлено на 5. В следующий раз при прохождении цикла это изменение также приводит к изменению направления яркости. 
  analogWrite () может очень быстро изменить значение ШИМ, поэтому задержка в конце эскиза контролирует скорость замирания.  Попробуйте изменить значение задержки и посмотрите, как она меняет эффект затухания. 
  Результат 
  Вы должны видеть, что яркость светодиодов меняется постепенно. 
  Arduino - чтение аналогового напряжения 
  В этом примере показано, как прочитать аналоговый вход на аналоговом выводе 0. Вход преобразуется из analogRead () в напряжение и распечатывается на последовательный монитор программного обеспечения Arduino (IDE). 
  Необходимые компоненты 
  Вам понадобятся следующие компоненты - 

  1 × макет 
  1 × Arduino Uno R3 
  Переменный резистор 1 × 5К (потенциометр) 
  2 × джемпер 

  Процедура 
  Следуйте электрической схеме и подключите компоненты на макете, как показано на рисунке ниже. 

  Потенциометр 
  Потенциометр (или горшок) - это простой электромеханический преобразователь.  Он преобразует вращательное или линейное движение от оператора ввода в изменение сопротивления.  Это изменение (или может быть) используется для управления чем-либо от объема системы Hi-Fi до направления огромного контейнеровоза. 
  Как мы знаем, сосуд изначально был известен как реостат (по сути, переменный проволочный резистор).  Разнообразие доступных горшков теперь удивительно, и начинающему (в частности) может быть очень трудно определить, какой тип подходит для данной задачи.  Несколько разных типов горшков, которые могут быть использованы для одной и той же задачи, усложняют работу. 

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

  Arduino Code 
/*
   ReadAnalogVoltage
   Reads an analog input on pin 0, converts it to voltage, 
   and prints the result to the serial monitor.
   Graphical representation is available using serial plotter (Tools > Serial Plotter menu)
   Attach the center pin of a potentiometer to pin A0, and the outside pins to +5V and ground.
*/

// the setup routine runs once when you press reset:

void setup() {
   // initialize serial communication at 9600 bits per second:
   Serial.begin(9600);
}

// the loop routine runs over and over again forever:

void loop() {
   // read the input on analog pin 0:
   int sensorValue = analogRead(A0);
   // Convert the analog reading (which goes from 0 - 1023) to a voltage (0 - 5V):
   float voltage = sensorValue * (5.0 / 1023.0);
   // print out the value you read:
   Serial.println(voltage);
}
  Код для заметки 
  В приведенной ниже программе или наброске первое, что вы делаете в функции настройки, - начинаете последовательную связь со скоростью 9600 бит / с между вашей платой и компьютером по линии - 
Serial.begin(9600);

  В основном цикле вашего кода вам нужно установить переменную для хранения значения сопротивления (которое будет между 0 и 1023, идеально подходит для типа данных int), поступающего от вашего потенциометра - 
int sensorValue = analogRead(A0);

  Чтобы изменить значения от 0-1023 до диапазона, соответствующего напряжению, вывод которого выводит вывод, необходимо создать еще одну переменную с плавающей точкой и выполнить небольшой расчет.  Чтобы масштабировать числа от 0,0 до 5,0, разделите 5,0 на 1023,0 и умножьте это на sensorValue - 
float voltage= sensorValue * (5.0 / 1023.0);

  Наконец, вам нужно распечатать эту информацию в вашем серийном окне.  Вы можете сделать это с помощью команды Serial.println () в вашей последней строке кода - 
Serial.println(voltage)

  Теперь откройте Serial Monitor в Arduino IDE, щелкнув значок с правой стороны верхней зеленой панели или нажав Ctrl + Shift + M. 

  Результат 
  Вы увидите устойчивый поток чисел в диапазоне от 0,0 до 5,0.  Когда вы поворачиваете горшок, значения будут меняться в соответствии с напряжением на выводе A0. 
  Arduino - светодиодная гистограмма 
  В этом примере показано, как прочитать аналоговый вход на аналоговом выводе 0, преобразовать значения из analogRead () в напряжение и распечатать его на последовательном мониторе программного обеспечения Arduino (IDE). 
  Необходимые компоненты 
  Вам понадобятся следующие компоненты - 

  1 × макет 
  1 × Arduino Uno R3 
  Переменный резистор 1х5 кОм (потенциометр) 
  2 × джемпер 
  8 × светодиод или вы можете использовать (светодиодная гистограмма, как показано на рисунке ниже) 

  Процедура 
  Следуйте электрической схеме и подключите компоненты на макете, как показано на рисунке ниже. 


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

  10-сегментная светодиодная гистограмма 

  Эти 10-сегментные гистограммы имеют множество применений.  Благодаря компактным размерам, простому подключению, они просты для прототипа или готовой продукции.  По сути, они представляют собой 10 отдельных синих светодиодов, размещенных вместе, каждый с отдельным анодным и катодным соединением. 
  Они также доступны в желтом, красном и зеленом цветах. 
  Примечание . Распиновка на этих гистограммах может отличаться от той, что указана в техническом описании.  Поворот устройства на 180 градусов исправит изменение, сделав вывод 11 первым в линии. 
  Arduino Code 
/*
   LED bar graph
   Turns on a series of LEDs based on the value of an analog sensor. 
   This is a simple way to make a bar graph display. 
   Though this graph uses 8LEDs, you can use any number by
      changing the LED count and the pins in the array.
   This method can be used to control any series of digital
      outputs that depends on an analog input.
*/

// these constants won't change:
const int analogPin = A0; // the pin that the potentiometer is attached to
const int ledCount = 8; // the number of LEDs in the bar graph
int ledPins[] = {2, 3, 4, 5, 6, 7, 8, 9}; // an array of pin numbers to which LEDs are attached

void setup() {
   // loop over the pin array and set them all to output:
   for (int thisLed = 0; thisLed < ledCount; thisLed++) {
      pinMode(ledPins[thisLed], OUTPUT);
   }
}

void loop() {
   // read the potentiometer:
   int sensorReading = analogRead(analogPin);
   // map the result to a range from 0 to the number of LEDs:
   int ledLevel = map(sensorReading, 0, 1023, 0, ledCount);
   // loop over the LED array:
   for (int thisLed = 0; thisLed < ledCount; thisLed++) {
      // if the array element's index is less than ledLevel,
      // turn the pin for this element on:
      if (thisLed < ledLevel) {
         digitalWrite(ledPins[thisLed], HIGH);
      }else { // turn off all pins higher than the ledLevel:
         digitalWrite(ledPins[thisLed], LOW);
      }
   }
} 
  Код для заметки 
  Эскиз работает так: сначала вы читаете ввод.  Вы отображаете входное значение в выходной диапазон, в этом случае десять светодиодов.  Затем вы настраиваете цикл for для перебора выходных данных.  Если номер выхода в серии ниже, чем сопоставленный входной диапазон, вы включаете его.  Если нет, выключите его. 
  Результат 
  Вы увидите, что светодиод включится один за другим, когда значение аналогового показания возрастет, и выключится один за другим, пока показание уменьшается. 
  Arduino - клавиатурный выход 
  В этом примере библиотека Keyboard используется для выхода из сеанса пользователя на компьютере, когда контакт 2 на ARDUINO UNO установлен на землю.  Эскиз моделирует нажатие клавиш в последовательности двух или трех клавиш одновременно и после небольшой задержки освобождает их. 
  Предупреждение. Когда вы используете команду Keyboard.print () , Arduino берет на себя клавиатуру вашего компьютера.  Чтобы не потерять контроль над компьютером во время выполнения эскиза с помощью этой функции, настройте надежную систему управления перед вызовом Keyboard.print ().  Этот эскиз предназначен для отправки команды клавиатуры только после того, как штифт был заземлен. 
  Необходимые компоненты 
  Вам понадобятся следующие компоненты - 

  1 × макет 
  1 × Arduino Leonardo, Micro или Due Board 
  1 × кнопка 
  1 × перемычка 

  Процедура 
  Следуйте электрической схеме и подключите компоненты на макете, как показано на рисунке ниже. 

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

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

  Arduino Code 
/*
   Keyboard logout
   This sketch demonstrates the Keyboard library.
   When you connect pin 2 to ground, it performs a logout.
   It uses keyboard combinations to do this, as follows:
   On Windows, CTRL-ALT-DEL followed by ALT-l
   On Ubuntu, CTRL-ALT-DEL, and ENTER
   On OSX, CMD-SHIFT-q
   To wake: Spacebar.
   Circuit:
   * Arduino Leonardo or Micro
   * wire to connect D2 to ground.
*/

#define OSX 0
#define WINDOWS 1
#define UBUNTU 2

#include "Keyboard.h"

// change this to match your platform:
int platform = WINDOWS;

void setup() {
   // make pin 2 an input and turn on the
   // pullup resistor so it goes high unless
   // connected to ground:
   
   pinMode(2, INPUT_PULLUP);
   Keyboard.begin();
}

void loop() {
   while (digitalRead(2) == HIGH) {
      // do nothing until pin 2 goes low
      delay(500);
   }
   
   delay(1000);
   
   switch (platform) {
      case OSX:
      Keyboard.press(KEY_LEFT_GUI);
	  
      // Shift-Q logs out:
      Keyboard.press(KEY_LEFT_SHIFT);
      Keyboard.press('Q');
      delay(100);
	  
      // enter:
      Keyboard.write(KEY_RETURN);
      break;
	  
      case WINDOWS:
      // CTRL-ALT-DEL:
      Keyboard.press(KEY_LEFT_CTRL);
      Keyboard.press(KEY_LEFT_ALT);
      Keyboard.press(KEY_DELETE);
      delay(100);
      Keyboard.releaseAll();
	  
      //ALT-l:
      delay(2000);
      Keyboard.press(KEY_LEFT_ALT);
      Keyboard.press('l');
      Keyboard.releaseAll();
      break;
	  
      case UBUNTU:
      // CTRL-ALT-DEL:
      Keyboard.press(KEY_LEFT_CTRL);
      Keyboard.press(KEY_LEFT_ALT);
      Keyboard.press(KEY_DELETE);
	  
      delay(1000);
      Keyboard.releaseAll();
	  
      // Enter to confirm logout:
      Keyboard.write(KEY_RETURN);
      break;
   }
   
   // do nothing:
   while (true);
}

Keyboard.releaseAll();

   // enter:
      Keyboard.write(KEY_RETURN);
      break;
      case WINDOWS:
	  
   // CTRL-ALT-DEL:
      Keyboard.press(KEY_LEFT_CTRL);
      Keyboard.press(KEY_LEFT_ALT);
      Keyboard.press(KEY_DELETE);
      delay(100);
      Keyboard.releaseAll();
	  
   //ALT-l:
      delay(2000);
      Keyboard.press(KEY_LEFT_ALT);
      Keyboard.press('l');
      Keyboard.releaseAll();
      break;
	  
   case UBUNTU:
      // CTRL-ALT-DEL:
      Keyboard.press(KEY_LEFT_CTRL);
      Keyboard.press(KEY_LEFT_ALT);
      Keyboard.press(KEY_DELETE);
      delay(1000);
      Keyboard.releaseAll();
	  
      // Enter to confirm logout:
      Keyboard.write(KEY_RETURN);
      break;
   }
   
// do nothing:
   while (true);
}
  Код для заметки 
  Перед тем, как загрузить программу на свою плату, убедитесь, что вы назначаете правильную ОС, которую вы используете в данный момент, переменной платформы. 
  Во время выполнения эскиза нажатие кнопки соединит контакт 2 с землей, и плата отправит последовательность выхода на ПК, подключенный через USB. 
  Результат 
  Когда вы подключаете контакт 2 к земле, он выполняет операцию выхода из системы. 
  Для выхода из системы используются следующие комбинации клавиш: 


  В Windows , CTRL-ALT-DEL, а затем ALT-l 


  В Ubuntu , CTRL-ALT-DEL и ENTER 


  На OSX , CMD-SHIFT-q 


  В Windows , CTRL-ALT-DEL, а затем ALT-l 
  В Ubuntu , CTRL-ALT-DEL и ENTER 
  На OSX , CMD-SHIFT-q 
  Arduino - сообщение клавиатуры 
  В этом примере, когда кнопка нажата, текстовая строка отправляется на компьютер в качестве ввода с клавиатуры.  Строка сообщает количество нажатий кнопки.  Когда вы запрограммируете и подключите Leonardo, откройте ваш любимый текстовый редактор, чтобы увидеть результаты. 
  Предупреждение. Когда вы используете команду Keyboard.print () , Arduino берет на себя клавиатуру вашего компьютера.  Чтобы не потерять контроль над компьютером во время выполнения эскиза с помощью этой функции, настройте надежную систему управления перед вызовом Keyboard.print () .  Этот эскиз включает в себя кнопку для переключения клавиатуры, чтобы она работала только после нажатия кнопки. 
  Необходимые компоненты 
  Вам понадобятся следующие компоненты - 

  1 × макет 
  1 × Arduino Leonardo, Micro или Due Board 
  1 × кратковременная кнопка 
  Резистор 1 × 10 кОм 

  Процедура 
  Следуйте электрической схеме и подключите компоненты на макете, как показано на рисунке ниже. 

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

  Arduino Code 
/*
   Keyboard Message test For the Arduino Leonardo and Micro,
      Sends a text string when a button is pressed.
   The circuit:
   * pushbutton attached from pin 4 to +5V
   * 10-kilohm resistor attached from pin 4 to ground
*/

#include "Keyboard.h"
const int buttonPin = 4; // input pin for pushbutton
int previousButtonState = HIGH; // for checking the state of a pushButton
int counter = 0; // button push counter

void setup() {
   pinMode(buttonPin, INPUT); // make the pushButton pin an input:
   Keyboard.begin(); // initialize control over the keyboard:
}

void loop() {
   int buttonState = digitalRead(buttonPin); // read the pushbutton:
   if ((buttonState != previousButtonState)&& (buttonState == HIGH)) // and it's currently pressed: {
      // increment the button counter
      counter++;
      // type out a message
      Keyboard.print("You pressed the button ");
      Keyboard.print(counter);
      Keyboard.println(" times.");
   }
   // save the current button state for comparison next time:
   previousButtonState = buttonState;
}
  Код для заметки 
  Прикрепите одну клемму кнопки к контакту 4 на Arduino.  Присоедините другой контакт к 5В.  Используйте резистор в качестве опускания, обеспечивая привязку к земле, прикрепив его от контакта 4 к земле. 
  Как только вы запрограммировали свою плату, отсоедините USB-кабель, откройте текстовый редактор и поместите текстовый курсор в область ввода.  Снова подключите плату к компьютеру через USB и нажмите кнопку, чтобы записать документ. 
  Результат 
  Используя любой текстовый редактор, он будет отображать текст, отправленный через Arduino. 
  Arduino - управление мышью 
  Используя библиотеку Mouse, вы можете управлять экранным курсором компьютера с помощью Arduino Leonardo, Micro или Due. 
  В этом конкретном примере используются пять кнопок для перемещения экранного курсора.  Четыре кнопки направлены (вверх, вниз, влево, вправо), а одна - для щелчка левой кнопкой мыши.  Движение курсора от Arduino всегда относительно.  Каждый раз, когда ввод читается, позиция курсора обновляется относительно его текущей позиции. 
  Всякий раз, когда нажимается одна из кнопок со стрелками, Arduino перемещает мышь, отображая HIGH-вход в диапазон от 5 в соответствующем направлении. 
  Пятая кнопка предназначена для управления левым щелчком мыши.  Когда кнопка отпущена, компьютер распознает событие. 
  Необходимые компоненты 
  Вам понадобятся следующие компоненты - 

  1 × макет 
  1 × Arduino Leonardo, Micro или Due Board 
  Резистор 5 × 10 кОм 
  5 × мгновенные кнопки 

  Процедура 
  Следуйте электрической схеме и подключите компоненты на макете, как показано на рисунке ниже. 

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

  Arduino Code 
/*
   Button Mouse Control
   For Leonardo and Due boards only .Controls the mouse from 
   five pushbuttons on an Arduino Leonardo, Micro or Due.
   Hardware:
   * 5 pushbuttons attached to D2, D3, D4, D5, D6
   The mouse movement is always relative. This sketch reads
   four pushbuttons, and uses them to set the movement of the mouse.
   WARNING: When you use the Mouse.move() command, the Arduino takes
   over your mouse! Make sure you have control before you use the mouse commands.
*/

#include "Mouse.h"
// set pin numbers for the five buttons:
const int upButton = 2;
const int downButton = 3;
const int leftButton = 4;
const int rightButton = 5;
const int mouseButton = 6;
int range = 5; // output range of X or Y movement; affects movement speed
int responseDelay = 10; // response delay of the mouse, in ms

void setup() {
   // initialize the buttons' inputs:
   pinMode(upButton, INPUT);
   pinMode(downButton, INPUT);
   pinMode(leftButton, INPUT);
   pinMode(rightButton, INPUT);
   pinMode(mouseButton, INPUT);
   // initialize mouse control:
   Mouse.begin();
}

void loop() {
   // read the buttons:
   int upState = digitalRead(upButton);
   int downState = digitalRead(downButton);
   int rightState = digitalRead(rightButton);
   int leftState = digitalRead(leftButton);
   int clickState = digitalRead(mouseButton);
   // calculate the movement distance based on the button states:
   int xDistance = (leftState - rightState) * range;
   int yDistance = (upState - downState) * range;
   // if X or Y is non-zero, move:
   if ((xDistance != 0) || (yDistance != 0)) {
      Mouse.move(xDistance, yDistance, 0);
   }

   // if the mouse button is pressed:
   if (clickState == HIGH) {
      // if the mouse is not pressed, press it:
      if (!Mouse.isPressed(MOUSE_LEFT)) {
         Mouse.press(MOUSE_LEFT);
      }
   } else {                           // else the mouse button is not pressed:
      // if the mouse is pressed, release it:
      if (Mouse.isPressed(MOUSE_LEFT)) {
         Mouse.release(MOUSE_LEFT);
      }
   }
   // a delay so the mouse does not move too fast:
   delay(responseDelay);
}
  Код для заметки 
  Подключите плату к компьютеру с помощью кабеля micro-USB.  Кнопки подключены к цифровым входам от контактов 2 до 6. Убедитесь, что используются резисторы 10 кОм. 
  Arduino - Серийная клавиатура 
  В этом примере прослушивается байт, поступающий с последовательного порта.  После получения плата отправляет нажатие клавиши обратно на компьютер.  Отправленное нажатие на клавишу выше, чем получено, поэтому, если вы отправите «a» с последовательного монитора, вы получите «b» с платы, подключенной к компьютеру.  «1» вернет «2» и так далее. 
  Предупреждение. Когда вы используете команду Keyboard.print () , плата Leonardo, Micro или Due берет на себя клавиатуру вашего компьютера.  Чтобы не потерять контроль над компьютером во время выполнения эскиза с помощью этой функции, настройте надежную систему управления перед вызовом Keyboard.print ().  Этот эскиз предназначен для отправки команды клавиатуры только после того, как плата получила байт через последовательный порт. 
  Необходимые компоненты 
  Вам понадобятся следующие компоненты - 

  1 × Arduino Leonardo, Micro или Due Board 

  Процедура 
  Просто подключите вашу плату к компьютеру с помощью USB-кабеля. 

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

  Примечания - Вы должны включить библиотеку клавиатуры в свой файл библиотеки Arduino.  Скопируйте и вставьте файл библиотеки клавиатуры внутри файла с именем «библиотеки», выделенным желтым цветом. 

  Arduino Code 
/*
   Keyboard test
   For the Arduino Leonardo, Micro or Due Reads
      a byte from the serial port, sends a keystroke back. 
   The sent keystroke is one higher than what's received, e.g. if you send a, you get b, send
      A you get B, and so forth.
   The circuit:
   * none
*/

#include "Keyboard.h"

void setup() {
   // open the serial port:
   Serial.begin(9600);
   // initialize control over the keyboard:
   Keyboard.begin();
}

void loop() {
   // check for incoming serial data:
   if (Serial.available() > 0) {
      // read incoming serial data:
      char inChar = Serial.read();
      // Type the next ASCII value from what you received:
      Keyboard.write(inChar + 1);
   }
}
  Код для заметки 
  После программирования откройте серийный монитор и отправьте байт.  Доска ответит нажатием клавиши, то есть на одну цифру выше. 
  Результат 
  Плата ответит нажатием клавиши, которая на один номер выше на последовательном мониторе Arduino IDE, когда вы отправите байт. 
  Arduino - датчик влажности 
  В этом разделе мы узнаем, как связать нашу плату Arduino с различными датчиками.  Мы обсудим следующие датчики - 

  Датчик влажности (DHT22) 
  Датчик температуры (LM35) 
  Датчик детектора воды (Simple Water Trigger) 
  PIR SENSOR 
  УЛЬТРАЗВУКОВОЙ ДАТЧИК 
  GPS 

  Датчик влажности (DHT22) 
  DHT-22 (также называемый AM2302) - это цифровой выход, датчик относительной влажности и температуры.  Он использует емкостный датчик влажности и термистор для измерения окружающего воздуха и посылает цифровой сигнал на вывод данных. 
  В этом примере вы узнаете, как использовать этот датчик с Arduino UNO.  Температура и влажность в помещении будут распечатаны на последовательном мониторе. 
  Датчик DHT-22 

  Связи просты.  Первый вывод слева для питания 3-5В, второй вывод для вывода ввода данных и самый правый вывод для заземления. 
  Технические детали 


  Мощность - 3-5В 


  Максимальный ток - 2,5 мА 


  Влажность - 0-100%, точность 2-5% 


  Температура - от 40 до 80 ° C, точность ± 0,5 ° C 


  Мощность - 3-5В 
  Максимальный ток - 2,5 мА 
  Влажность - 0-100%, точность 2-5% 
  Температура - от 40 до 80 ° C, точность ± 0,5 ° C 
  Необходимые компоненты 
  Вам понадобятся следующие компоненты - 

  1 × макет 
  1 × Arduino Uno R3 
  1 × DHT22 
  Резистор 1 × 10 кОм 

  Процедура 
  Следуйте электрической схеме и подключите компоненты на макете, как показано на рисунке ниже. 


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

  Arduino Code 
// Example testing sketch for various DHT humidity/temperature sensors

#include "DHT.h"
#define DHTPIN 2 // what digital pin we're connected to
// Uncomment whatever type you're using!
//#define DHTTYPE DHT11 // DHT 11
#define DHTTYPE DHT22 // DHT 22 (AM2302), AM2321
//#define DHTTYPE DHT21 // DHT 21 (AM2301)
// Connect pin 1 (on the left) of the sensor to +5V
// NOTE: If using a board with 3.3V logic like an Arduino Due connect pin 1
// to 3.3V instead of 5V!
// Connect pin 2 of the sensor to whatever your DHTPIN is
// Connect pin 4 (on the right) of the sensor to GROUND
// Connect a 10K resistor from pin 2 (data) to pin 1 (power) of the sensor
// Initialize DHT sensor.
// Note that older versions of this library took an optional third parameter to
// tweak the timings for faster processors. This parameter is no longer needed
// as the current DHT reading algorithm adjusts itself to work on faster procs.
DHT dht(DHTPIN, DHTTYPE);

void setup() {
   Serial.begin(9600);
   Serial.println("DHTxx test!");
   dht.begin();
}

void loop() {
   delay(2000); // Wait a few seconds between measurements
   float h = dht.readHumidity();
   // Reading temperature or humidity takes about 250 milliseconds!
   float t = dht.readTemperature();
   // Read temperature as Celsius (the default)
   float f = dht.readTemperature(true);
   // Read temperature as Fahrenheit (isFahrenheit = true)
   // Check if any reads failed and exit early (to try again).
   if (isnan(h) || isnan(t) || isnan(f)) {
      Serial.println("Failed to read from DHT sensor!");
      return;
   }
   
   // Compute heat index in Fahrenheit (the default)
   float hif = dht.computeHeatIndex(f, h);
   // Compute heat index in Celsius (isFahreheit = false)
   float hic = dht.computeHeatIndex(t, h, false);
   Serial.print ("Humidity: ");
   Serial.print (h);
   Serial.print (" %\t");
   Serial.print ("Temperature: ");
   Serial.print (t);
   Serial.print (" *C ");
   Serial.print (f);
   Serial.print (" *F\t");
   Serial.print ("Heat index: ");
   Serial.print (hic);
   Serial.print (" *C ");
   Serial.print (hif);
   Serial.println (" *F");
}
  Код для заметки 
  Датчик DHT22 имеет четыре клеммы (V cc , DATA, NC, GND), которые подключаются к плате следующим образом: 

  Контакт DATA на контакт Arduino № 2 
  Контакт V cc до 5 вольт платы Arduino 
  GND прикрепить к земле платы Arduino 
  Нам нужно подключить резистор 10 кОм (подтягивающий резистор) между DATA и выводом V cc 

  Как только аппаратные соединения выполнены, вам нужно добавить библиотеку DHT22 в файл библиотеки Arduino, как описано ранее. 
  Результат 
  Вы увидите дисплей температуры и влажности на мониторе последовательного порта, который обновляется каждые 2 секунды. 
  Arduino - Датчик температуры 
  Датчики температуры серии LM35 представляют собой прецизионные интегральные температурные устройства с выходным напряжением, линейно пропорциональным температуре Цельсия. 
  Устройство LM35 имеет преимущество перед линейными датчиками температуры, откалиброванными в Кельвинах, поскольку пользователю не требуется вычитать большое постоянное напряжение из выходного сигнала для получения удобного масштабирования по Цельсию.  Устройство LM35 не требует какой-либо внешней калибровки или подстройки для обеспечения типичной точности ± ± ° C при комнатной температуре и ± ¾ ° C в полном температурном диапазоне от –55 ° C до 150 ° C. 

  Технические характеристики 

  Откалиброван непосредственно в градусах Цельсия (по Цельсию) 
  Линейный + 10-мВ / ° C масштабный коэффициент 
  Точность 0,5 ° C (при 25 ° C) 
  Номинальный для полного диапазона от −55 ° C до 150 ° C 
  Подходит для удаленных приложений 

  Необходимые компоненты 
  Вам понадобятся следующие компоненты - 

  1 × макет 
  1 × Arduino Uno R3 
  1 × датчик LM35 

  Процедура 
  Следуйте электрической схеме и подключите компоненты на макете, как показано на рисунке ниже. 

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

  Arduino Code 
float temp;
int tempPin = 0;

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

void loop() {
   temp = analogRead(tempPin);
   // read analog volt from sensor and save to variable temp
   temp = temp * 0.48828125;
   // convert the analog volt to its temperature equivalent
   Serial.print("TEMPERATURE = ");
   Serial.print(temp); // display temperature value
   Serial.print("*C");
   Serial.println();
   delay(1000); // update sensor reading each one second
}
  Код для заметки 
  Датчик LM35 имеет три клеммы - V s , V out и GND.  Мы подключим датчик следующим образом - 

  Подключите + V s к + 5 В на вашей плате Arduino. 
  Подключите V out к Analog0 или A0 на плате Arduino. 
  Соедините GND с GND на Arduino. 

  Аналого-цифровой преобразователь (АЦП) преобразует аналоговые значения в цифровой аппроксимации на основе формулы ADC Value = образец * 1024 / опорное напряжение (+5 В).  Таким образом, при опоре +5 В цифровое приближение будет равно входному напряжению * 205. 
  Результат 
  Вы увидите дисплей температуры на мониторе последовательного порта, который обновляется каждую секунду. 
  Arduino - детектор воды / датчик 
  Блок датчика воды предназначен для обнаружения воды, который может широко использоваться для обнаружения дождя, уровня воды и даже утечки жидкости. 

  Подключение датчика воды к Arduino - отличный способ обнаружить утечку, разлив, наводнение, дождь и т. Д. Он может использоваться для определения наличия, уровня, объема и / или отсутствия воды.  Хотя это можно использовать для напоминания о поливе ваших растений, для этого есть лучший датчик Grove.  Датчик имеет массив открытых следов, которые показывают НИЗКИЙ при обнаружении воды. 
  В этой главе мы подключим датчик воды к цифровому контакту 8 на Arduino и включим очень удобный светодиод, чтобы помочь определить, когда датчик воды соприкасается с источником воды. 
  Необходимые компоненты 
  Вам понадобятся следующие компоненты - 

  1 × макет 
  1 × Arduino Uno R3 
  1 × Датчик воды 
  1 × светодиод 
  Резистор 1 × 330 Ом 

  Процедура 
  Следуйте электрической схеме и подключите компоненты на макете, как показано на рисунке ниже. 

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

  Arduino Code 
#define Grove_Water_Sensor 8 // Attach Water sensor to Arduino Digital Pin 8
#define LED 9 // Attach an LED to Digital Pin 9 (or use onboard LED)

void setup() {
   pinMode(Grove_Water_Sensor, INPUT); // The Water Sensor is an Input
   pinMode(LED, OUTPUT); // The LED is an Output
}

void loop() {
   /* The water sensor will switch LOW when water is detected.
   Get the Arduino to illuminate the LED and activate the buzzer
   when water is detected, and switch both off when no water is present */
   if( digitalRead(Grove_Water_Sensor) == LOW) {
      digitalWrite(LED,HIGH);
   }else {
      digitalWrite(LED,LOW);
   }
}
  Код для заметки 
  Датчик воды имеет три клеммы - S, V out (+) и GND (-).  Подключите датчик следующим образом - 

  Подключите + V s к + 5 В на вашей плате Arduino. 
  Подключите S к цифровому выводу № 8 на плате Arduino. 
  Соедините GND с GND на Arduino. 
  Подключите светодиод к цифровому выводу № 9 на плате Arduino. 

  Когда датчик обнаруживает воду, контакт 8 на Arduino становится НИЗКИМ, и затем светодиод на Arduino включается. 
  Результат 
  Вы увидите, что светодиодный индикатор загорается, когда датчик обнаруживает воду. 
  Arduino - ИК-датчик 
  ИК-датчики позволяют вам чувствовать движение.  Они используются для определения того, вошел или нет человек в зону действия датчика.  Они обычно находятся в приборах и устройствах, используемых дома или для бизнеса.  Их часто называют ИК-датчиками, «пассивными инфракрасными», «пироэлектрическими» или «ИК-датчиками движения». 
  Ниже приведены преимущества ИК-датчиков - 

  Маленький по размеру 
  Широкий диапазон линз 
  Простота интерфейса 
  недорогой 
  Низкая мощность 
  Легко использовать 
  Не изнашиваться 


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

  PIR имеют регулируемые настройки и имеют разъем, установленный в 3-контактных контактах заземления / выхода / питания. 

  Для многих базовых проектов или продуктов, которые должны определять, когда человек покинул или вошел в зону, ИК-датчики отлично подходят.  Обратите внимание, что PIR не сообщают вам количество людей вокруг или их близость к датчику.  Линзы часто фиксируются на определенном расстоянии на расстоянии, и они иногда запускаются домашними животными в доме. 
  Необходимые компоненты 
  Вам понадобятся следующие компоненты - 

  1 × макет 
  1 × Arduino Uno R3 
  1 × ИК-датчик (MQ3) 

  Процедура 
  Следуйте электрической схеме и выполните соединения, как показано на рисунке ниже. 

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

  Arduino Code 
#define pirPin 2
int calibrationTime = 30;
long unsigned int lowIn;
long unsigned int pause = 5000;
boolean lockLow = true;
boolean takeLowTime;
int PIRValue = 0;

void setup() {
   Serial.begin(9600);
   pinMode(pirPin, INPUT);
}

void loop() {
   PIRSensor();
}

void PIRSensor() {
   if(digitalRead(pirPin) == HIGH) {
      if(lockLow) {
         PIRValue = 1;
         lockLow = false;
         Serial.println("Motion detected.");
         delay(50);
      }
      takeLowTime = true;
   }
   if(digitalRead(pirPin) == LOW) {
      if(takeLowTime){
         lowIn = millis();takeLowTime = false;
      }
      if(!lockLow && millis() - lowIn > pause) {
         PIRValue = 0;
         lockLow = true;
         Serial.println("Motion ended.");
         delay(50);
      }
   }
}
  Код для заметки 
  ИК-датчик имеет три клеммы - V cc , OUT и GND.  Подключите датчик следующим образом - 

  Подключите + V cc к + 5 В на плате Arduino. 
  Подключите OUT к цифровому контакту 2 на плате Arduino. 
  Соедините GND с GND на Arduino. 

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

  Как только датчик обнаружит любое движение, Arduino отправит сообщение через последовательный порт, чтобы сообщить, что движение обнаружено.  Движение PIR Sense задержит на определенное время, чтобы проверить, есть ли новое движение.  Если движение не обнаружено, Arduino отправит новое сообщение о том, что движение завершено. 
  Результат 
  Вы увидите сообщение на вашем последовательном порту, если движение обнаружено, и другое сообщение, когда движение остановится. 
  Arduino - ультразвуковой датчик 
  Ультразвуковой датчик HC-SR04 использует SONAR для определения расстояния до объекта так же, как летучие мыши.  Он предлагает превосходное бесконтактное определение дальности с высокой точностью и стабильными показаниями в удобной упаковке от 2 см до 400 см или от 1 до 13 футов. 
  На работу не влияет солнечный свет или черный материал, хотя акустически мягкие материалы, такие как ткань, трудно обнаружить.  Он поставляется в комплекте с ультразвуковым передатчиком и приемником. 


  Технические характеристики 

  Электропитание - + 5 В постоянного тока 
  Ток покоя - <2 мА 
  Рабочий ток - 15 мА 
  Эффектный угол - <15 ° 
  Расстояние от - 2 см до 400 см / 1 ″ - 13 футов 
  Разрешение - 0,3 см 
  Угол измерения - 30 градусов 

  Необходимые компоненты 
  Вам понадобятся следующие компоненты - 

  1 × макет 
  1 × Arduino Uno R3 
  1 × УЛЬТРАЗВУКОВОЙ датчик (HC-SR04) 

  Процедура 
  Следуйте электрической схеме и выполните соединения, как показано на рисунке ниже. 

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

  Arduino Code 
const int pingPin = 7; // Trigger Pin of Ultrasonic Sensor
const int echoPin = 6; // Echo Pin of Ultrasonic Sensor

void setup() {
   Serial.begin(9600); // Starting Serial Terminal
}

void loop() {
   long duration, inches, cm;
   pinMode(pingPin, OUTPUT);
   digitalWrite(pingPin, LOW);
   delayMicroseconds(2);
   digitalWrite(pingPin, HIGH);
   delayMicroseconds(10);
   digitalWrite(pingPin, LOW);
   pinMode(echoPin, INPUT);
   duration = pulseIn(echoPin, HIGH);
   inches = microsecondsToInches(duration);
   cm = microsecondsToCentimeters(duration);
   Serial.print(inches);
   Serial.print("in, ");
   Serial.print(cm);
   Serial.print("cm");
   Serial.println();
   delay(100);
}

long microsecondsToInches(long microseconds) {
   return microseconds / 74 / 2;
}

long microsecondsToCentimeters(long microseconds) {
   return microseconds / 29 / 2;
}
  Код для заметки 
  Ультразвуковой датчик имеет четыре клеммы - + 5 В, триггер, эхо и GND, подключенные следующим образом - 

  Подключите контакт + 5В к + 5В на плате Arduino. 
  Подключите Trigger к цифровому контакту 7 на плате Arduino. 
  Подключите Echo к цифровому контакту 6 на вашей плате Arduino. 
  Соедините GND с GND на Arduino. 

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

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

  Необходимые компоненты 
  Вам понадобятся следующие компоненты - 

  1 × Arduino UNO доска 
  Резистор 1 × 330 Ом 
  Резистор 1 × 4,7 кОм (опускается) 
  1 × светодиод 

  Процедура 
  Следуйте электрической схеме и выполните соединения, как показано на рисунке ниже. 

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

  Arduino Code 
// constants won't change. They're used here to
// set pin numbers:
const int buttonPin = 8; // the number of the pushbutton pin
const int ledPin = 2; // the number of the LED pin
// variables will change:
int buttonState = 0; // variable for reading the pushbutton status

void setup() {
   // initialize the LED pin as an output:
   pinMode(ledPin, OUTPUT);
   // initialize the pushbutton pin as an input:
   pinMode(buttonPin, INPUT);
}

void loop() {
   // read the state of the pushbutton value:
   buttonState = digitalRead(buttonPin);
   // check if the pushbutton is pressed.
   // if it is, the buttonState is HIGH:
   if (buttonState == HIGH) {
      // turn LED on:
      digitalWrite(ledPin, HIGH);
   } else {
      // turn LED off:
      digitalWrite(ledPin, LOW);
   }
}
  Код для заметки 
  Когда переключатель разомкнут (кнопка не нажата), между двумя контактами кнопки нет соединения, поэтому контакт подключен к земле (через резистор понижающего напряжения), и мы читаем НИЗКИЙ.  Когда переключатель замкнут (кнопка нажата), он устанавливает соединение между двумя своими клеммами, соединяя штырь на 5 В, так что мы читаем ВЫСОКОЕ. 
  Результат 
  Светодиод включается при нажатии кнопки и выключается при отпускании. 
  Arduino - двигатель постоянного тока 
  В этой главе мы будем связывать различные типы двигателей с платой Arduino (UNO) и покажем вам, как подключить двигатель и управлять им с вашей платы. 
  Есть три разных типа двигателей - 

  Двигатель постоянного тока 
  Серводвигатель 
  Шаговый двигатель 

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

  Предупреждение. Запрещается приводить двигатель в движение непосредственно от выводов платы Arduino.  Это может повредить доску.  Используйте схему драйвера или IC. 
  Мы разделим эту главу на три части - 

  Просто сделай мотор крутится 
  Контроль скорости двигателя 
  Контролировать направление вращения двигателя постоянного тока 

  Необходимые компоненты 
  Вам понадобятся следующие компоненты - 

  1x Arduino UNO доска 
  1x PN2222 Транзистор 
  1x малый 6В постоянного тока 
  1x 1N4001 диод 
  1x 270 Ом Резистор 

  Процедура 
  Следуйте электрической схеме и выполните соединения, как показано на рисунке ниже. 

  Меры предосторожности 
  При подключении соблюдайте следующие меры предосторожности. 


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


  Во-вторых, полосатый конец диода должен быть направлен к линии питания + 5 В в соответствии с расположением, показанным на рисунке. 


  Сначала убедитесь, что транзистор подключен правильно.  Плоская сторона транзистора должна быть обращена к плате Arduino, как показано на схеме. 
  Во-вторых, полосатый конец диода должен быть направлен к линии питания + 5 В в соответствии с расположением, показанным на рисунке. 
  Spin ControlArduino Code 
int motorPin = 3;

void setup() {

}

void loop() {
   digitalWrite(motorPin, HIGH);
}
  Код для заметки 
  Транзистор действует как переключатель, управляющий питанием двигателя.  Контакт 3 Arduino используется для включения и выключения транзистора, и на эскизе ему присваивается название «motorPin». 
  Результат 
  Двигатель будет вращаться на полной скорости, когда вывод Arduino № 3 поднимется высоко. 
  Контроль скорости двигателя 
  Ниже приведена принципиальная схема двигателя постоянного тока, подключенного к плате Arduino. 

  Arduino Code 
int motorPin = 9;

void setup() {
   pinMode(motorPin, OUTPUT);
   Serial.begin(9600);
   while (! Serial);
   Serial.println("Speed 0 to 255");
}

void loop() {
   if (Serial.available()) {
      int speed = Serial.parseInt();
      if (speed >= 0 && speed <= 255) {
         analogWrite(motorPin, speed);
      }
   }
}
  Код для заметки 
  Транзистор действует как переключатель, управляющий мощностью двигателя.  Контакт 3 Arduino используется для включения и выключения транзистора, и на эскизе ему присваивается название «motorPin». 
  Когда программа запускается, она предлагает вам ввести значения для управления скоростью двигателя.  Вам необходимо ввести значение от 0 до 255 в Serial Monitor. 

  В функции «loop» команда «Serial.parseInt» используется для считывания числа, введенного в виде текста в Serial Monitor, и преобразования его в «int».  Вы можете ввести любой номер здесь.  Оператор 'if' в следующей строке просто выполняет аналоговую запись с этим номером, если число находится в диапазоне от 0 до 255. 
  Результат 
  Двигатель постоянного тока будет вращаться с различными скоростями в соответствии со значением (от 0 до 250), полученным через последовательный порт. 
  Контроль направления вращения 
  Для управления направлением вращения двигателя постоянного тока без замены проводов можно использовать схему, называемую H-мостом .  H-мост - это электронная схема, которая может управлять двигателем в обоих направлениях.  H-мосты используются во многих различных приложениях.  Одним из наиболее распространенных приложений является управление двигателями в роботах.  Он называется H-мостом, потому что он использует четыре транзистора, соединенных таким образом, что принципиальная схема выглядит как «H». 
  Мы будем использовать L298 H-Bridge IC здесь.  L298 может контролировать скорость и направление двигателей постоянного тока и шаговых двигателей, а также может управлять двумя двигателями одновременно.  Его текущий рейтинг составляет 2А для каждого двигателя.  Однако при таких токах вам необходимо использовать радиаторы. 

  Необходимые компоненты 
  Вам понадобятся следующие компоненты - 

  1 × L298 мостовая ИС 
  1 × двигатель постоянного тока 
  1 × Arduino UNO 
  1 × макет 
  10 × перемычек 

  Процедура 
  Ниже приведена принципиальная схема интерфейса двигателя постоянного тока с платой Arduino Uno. 

  На схеме выше показано, как подключить микросхему L298 для управления двумя двигателями.  Для каждого двигателя имеется три входных контакта: Вход1 (IN1), Вход2 (IN2) и Разрешить1 (EN1) для Двигателя1 и Вход3, Вход4 и Разрешить2 для Двигателя2. 
  Поскольку в этом примере мы будем управлять только одним двигателем, мы подключим Arduino к IN1 (контакт 5), IN2 (контакт 7) и Enable1 (контакт 6) микросхемы L298.  Контакты 5 и 7 являются цифровыми, т. Е. Входы ВКЛ или ВЫКЛ, а для вывода 6 требуется сигнал с широтно-импульсной модуляцией (ШИМ) для контроля скорости двигателя. 
  В следующей таблице показано направление вращения двигателя на основании цифровых значений IN1 и IN2. 



  В 1 
  IN2 
  Мотор Поведение 




  ТОРМОЗНАЯ 


  1 

  ВПЕРЕД 



  1 
  BACKWARD 


  1 
  1 
  ТОРМОЗНАЯ 



  Контакт IN1 микросхемы L298 подключен к контакту 8 Arduino, а IN2 подключен к контакту 9. Эти два цифровых контакта Arduino контролируют направление двигателя.  EN Контакт IC подключен к выводу 2 ШИМ Arduino.  Это будет контролировать скорость двигателя. 
  Чтобы установить значения выводов Arduino 8 и 9, мы использовали функцию digitalWrite (), а для установки значения вывода 2 мы должны использовать функцию analogWrite (). 
  Шаги подключения 

  Подключите 5V и заземление IC к 5V и заземлению Arduino соответственно. 
  Подключите двигатель к контактам 2 и 3 микросхемы. 
  Подключите IN1 IC к контакту 8 Arduino. 
  Подключите IN2 IC к контакту 9 Arduino. 
  Подключите EN1 IC к контакту 2 Arduino. 
  Подключите SENS A контакт IC к земле. 
  Подключите Arduino с помощью USB-кабеля Arduino и загрузите программу в Arduino с помощью программного обеспечения Arduino IDE. 
  Подайте питание на плату Arduino с помощью блока питания, аккумулятора или USB-кабеля. 

  Arduino Code 
const int pwm = 2 ; //initializing pin 2 as pwm
const int in_1 = 8 ;
const int in_2 = 9 ;
//For providing logic to L298 IC to choose the direction of the DC motor

void setup() {
   pinMode(pwm,OUTPUT) ; //we have to set PWM pin as output
   pinMode(in_1,OUTPUT) ; //Logic pins are also set as output
   pinMode(in_2,OUTPUT) ;
}

void loop() {
   //For Clock wise motion , in_1 = High , in_2 = Low
   digitalWrite(in_1,HIGH) ;
   digitalWrite(in_2,LOW) ;
   analogWrite(pwm,255) ;
   /* setting pwm of the motor to 255 we can change the speed of rotation
   by changing pwm input but we are only using arduino so we are using highest
   value to driver the motor */
   //Clockwise for 3 secs
   delay(3000) ;
   //For brake
   digitalWrite(in_1,HIGH) ;
   digitalWrite(in_2,HIGH) ;
   delay(1000) ;
   //For Anti Clock-wise motion - IN_1 = LOW , IN_2 = HIGH
   digitalWrite(in_1,LOW) ;
   digitalWrite(in_2,HIGH) ;
   delay(3000) ;
   //For brake
   digitalWrite(in_1,HIGH) ;
   digitalWrite(in_2,HIGH) ;
   delay(1000) ;
}
  Результат 
  Двигатель будет сначала вращаться в направлении по часовой стрелке (CW) в течение 3 секунд, а затем в течение 3 секунд против часовой стрелки (CCW). 
  Arduino - Серво Мотор 
  Сервомотор - это небольшое устройство с выходным валом.  Этот вал может быть установлен в определенное угловое положение, посылая сервокод кодированный сигнал.  Пока кодированный сигнал присутствует на входной линии, сервопривод будет поддерживать угловое положение вала.  Если кодированный сигнал изменяется, угловое положение вала изменяется.  На практике сервоприводы используются в радиоуправляемых самолетах для позиционирования поверхностей управления, таких как лифты и рули направления.  Они также используются в радиоуправляемых автомобилях, марионетках и, конечно же, роботах. 

  Сервоприводы чрезвычайно полезны в робототехнике.  Двигатели маленькие, имеют встроенную схему управления и очень мощные по своим размерам.  Стандартный сервопривод, такой как Futaba S-148, имеет крутящий момент 42 унции / дюйм, что является сильным для его размера.  Он также потребляет мощность, пропорциональную механической нагрузке.  Поэтому слегка нагруженный сервопривод не потребляет много энергии. 
  Кишки серводвигателя показаны на следующем рисунке.  Вы можете увидеть схему управления, двигатель, набор передач и корпус.  Вы также можете увидеть 3 провода, которые подключаются к внешнему миру.  Один для питания (+ 5 вольт), заземления, а белый провод - провод управления. 

  Работа серводвигателя 
  Серводвигатель имеет несколько цепей управления и потенциометр (переменный резистор, или резистор), подключенный к выходному валу.  На картинке выше, горшок можно увидеть на правой стороне печатной платы.  Этот бак позволяет схеме управления контролировать текущий угол серводвигателя. 
  Если вал находится под правильным углом, то двигатель отключается.  Если цепь обнаружит, что угол неправильный, она будет вращать двигатель, пока он не окажется под нужным углом.  Выходной вал сервопривода способен перемещаться где-то на 180 градусов.  Обычно это где-то в диапазоне 210 градусов, однако, это зависит от производителя.  Обычный сервопривод используется для контроля углового движения от 0 до 180 градусов.  Механически он не способен вращаться дальше из-за механического упора, встроенного в основной выходной механизм. 
  Мощность, приложенная к двигателю, пропорциональна расстоянию, которое необходимо пройти.  Таким образом, если вал должен вращаться на большое расстояние, двигатель будет работать на полной скорости.  Если ему нужно повернуть только небольшое количество, двигатель будет работать с меньшей скоростью.  Это называется пропорциональным контролем . 
  Как вы сообщаете угол, под которым должен поворачиваться сервопривод? 
  Управляющий провод используется для сообщения угла.  Угол определяется длительностью импульса, подаваемого на контрольный провод.  Это называется импульсной кодовой модуляцией .  Серво ожидает импульса каждые 20 миллисекунд (0,02 секунды).  Длина импульса будет определять, как далеко двигатель поворачивает.  Например, импульс в 1,5 миллисекунды заставит двигатель повернуться в положение на 90 градусов (часто называемое нейтральным положением).  Если импульс короче 1,5 миллисекунд, то двигатель повернет вал ближе к 0 градусам.  Если импульс дольше 1,5 миллисекунд, вал поворачивается ближе к 180 градусам. 

  Необходимые компоненты 
  Вам понадобятся следующие компоненты - 

  1 × Arduino UNO доска 
  1 × Серводвигатель 
  1 × ULN2003 управляющая микросхема 
  Резистор 1 × 10 кОм 

  Процедура 
  Следуйте электрической схеме и выполните соединения, как показано на рисунке ниже. 

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

  Arduino Code 
/* Controlling a servo position using a potentiometer (variable resistor) */

#include <Servo.h>
   Servo myservo; // create servo object to control a servo
   int potpin = 0; // analog pin used to connect the potentiometer
   int val; // variable to read the value from the analog pin

void setup() {
   myservo.attach(9); // attaches the servo on pin 9 to the servo object
}

void loop() {
   val = analogRead(potpin);
   // reads the value of the potentiometer (value between 0 and 1023)
   val = map(val, 0, 1023, 0, 180);
   // scale it to use it with the servo (value between 0 and 180)
   myservo.write(val); // sets the servo position according to the scaled value
   delay(15);
}
  Код для заметки 
  Серводвигатели имеют три клеммы - мощность, земля и сигнал.  Провод питания обычно красного цвета и должен быть подключен к 5-вольтовому выводу на Arduino.  Провод заземления обычно черный или коричневый и должен быть подключен к одной клемме микросхемы ULN2003 (10 -16).  Чтобы защитить плату Arduino от повреждений, вам понадобится микросхема драйвера для этого.  Здесь мы использовали микросхему ULN2003 для управления серводвигателем.  Сигнальный контакт обычно желтый или оранжевый и должен быть подключен к контакту Arduino № 9. 
  Подключение потенциометра 
  Делитель напряжения / делитель потенциала - это резисторы в последовательной цепи, которые масштабируют выходное напряжение в соответствии с конкретным отношением приложенного входного напряжения.  Ниже приведена принципиальная схема - 

  $$ V_ {out} = (V_ {in} \ times R_ {2}) / (R_ {1} + R_ {2}) $$ 
  V out - выходной потенциал, который зависит от приложенного входного напряжения (V in ) и резисторов (R 1 и R 2 ) в серии.  Это означает, что ток, протекающий через R 1 , также будет протекать через R 2 без разделения.  В приведенном выше уравнении при изменении значения R 2 V out масштабируется соответственно относительно входного напряжения V in . 
  Как правило, потенциометр представляет собой делитель потенциала, который может масштабировать выходное напряжение цепи на основе значения переменного резистора, который масштабируется с помощью ручки.  Он имеет три контакта: GND, Signal и + 5V, как показано на рисунке ниже - 

  Результат 
  Изменяя положение NOP горшка, серводвигатель изменит свой угол. 
  Arduino - шаговый двигатель 
  Шаговый двигатель или шаговый двигатель - это бесщеточный синхронный двигатель, который делит полный оборот на несколько ступеней.  В отличие от бесщеточного двигателя постоянного тока, который непрерывно вращается, когда к нему прикладывается постоянное напряжение постоянного тока, шаговый двигатель вращается в дискретных шагах под углом. 
  По этой причине шаговые двигатели изготавливаются с шагом на оборот 12, 24, 72, 144, 180 и 200, что приводит к шаговым углам 30, 15, 5, 2,5, 2 и 1,8 градуса на шаг.  Шаговым двигателем можно управлять с обратной связью или без нее. 
  Вообразите двигатель на самолете RC.  Мотор вращается очень быстро в одном или другом направлении.  Вы можете изменять скорость в зависимости от мощности, подаваемой на двигатель, но вы не можете сказать пропеллеру остановиться в определенной позиции. 
  Теперь представьте себе принтер.  Внутри принтера много движущихся частей, включая двигатели.  Один из таких двигателей действует как подача бумаги, вращающиеся ролики, которые перемещают лист бумаги, когда на нем печатаются чернила.  Этот мотор должен иметь возможность перемещать бумагу на точное расстояние, чтобы можно было напечатать следующую строку текста или следующую строку изображения. 
  К стержню с резьбой прикреплен другой двигатель, который перемещает печатающую головку вперед и назад.  Опять же, этот стержень с резьбой необходимо перемещать на точное количество, чтобы печатать одну букву за другой.  Здесь пригодятся шаговые двигатели. 

  Как работает шаговый двигатель? 
  Обычный двигатель постоянного тока вращается только в одном направлении, тогда как шаговый двигатель может вращаться с точным шагом. 
  Шаговые двигатели могут поворачивать точное количество градусов (или шагов) по желанию.  Это дает вам полный контроль над двигателем, позволяя вам переместить его в точное место и удерживать это положение.  Это достигается за счет питания катушек внутри двигателя в течение очень коротких периодов времени.  Недостатком является то, что вы должны постоянно приводить двигатель в действие, чтобы удерживать его в желаемом положении. 
  Все, что вам нужно знать на данный момент, это то, что для перемещения шагового двигателя вы говорите ему, чтобы он двигался на определенное количество шагов в одном или другом направлении, и сообщаете ему скорость, с которой нужно двигаться в этом направлении.  Существует множество разновидностей шаговых двигателей.  Методы, описанные здесь, могут быть использованы для определения того, как использовать другие двигатели и драйверы, которые не упомянуты в этом руководстве.  Тем не менее, всегда рекомендуется обращаться к техническим данным и руководствам по двигателям и драйверам, относящимся к имеющимся у вас моделям. 

  Необходимые компоненты 
  Вам понадобятся следующие компоненты - 

  1 × Arduino UNO доска 
  1 × маленький биполярный шаговый двигатель, как показано на рисунке ниже 
  1 × LM298 управляющая микросхема 


  Процедура 
  Следуйте электрической схеме и выполните соединения, как показано на рисунке ниже. 

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

  Arduino Code 
/* Stepper Motor Control */

#include <Stepper.h>
const int stepsPerRevolution = 90;
// change this to fit the number of steps per revolution
// for your motor
// initialize the stepper library on pins 8 through 11:
Stepper myStepper(stepsPerRevolution, 8, 9, 10, 11);

void setup() {
   // set the speed at 60 rpm:
   myStepper.setSpeed(5);
   // initialize the serial port:
   Serial.begin(9600);
}

void loop() {
   // step one revolution in one direction:
   Serial.println("clockwise");
   myStepper.step(stepsPerRevolution);
   delay(500);
   // step one revolution in the other direction:
   Serial.println("counterclockwise");
   myStepper.step(-stepsPerRevolution);
   delay(500);
}
  Код для заметки 
  Эта программа приводит в движение однополярный или биполярный шаговый двигатель.  Двигатель прикреплен к цифровым контактам 8 - 11 Arduino. 
  Результат 
  Двигатель совершит один оборот в одном направлении, а затем один оборот в другом направлении. 
  Arduino - тональная библиотека 
  В этой главе мы будем использовать библиотеку тонов Arduino.  Это не что иное, как библиотека Arduino, которая генерирует прямоугольную волну определенной частоты (с коэффициентом заполнения 50%) на любом выводе Arduino.  При желании можно указать продолжительность, в противном случае волна продолжается до вызова функции stop ().  Контакт может быть подключен к пьезо-зуммеру или динамику для воспроизведения тонов. 
  Предупреждение. Не подключайте контакт непосредственно к любому аудиовходу.  Напряжение значительно выше, чем стандартные линейные напряжения, и может повредить входы звуковой карты и т. Д. Вы можете использовать делитель напряжения для понижения напряжения. 
  Необходимые компоненты 
  Вам понадобятся следующие компоненты - 

  Динамик 1 × 8 Ом 
  Резистор 1 × 1 кОм 
  1 × Arduino UNO доска 

  Процедура 
  Следуйте электрической схеме и выполните соединения, как показано на рисунке ниже. 

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

  Чтобы создать файл pitches.h, либо нажмите кнопку под значком последовательного монитора и выберите «Новая вкладка», либо используйте Ctrl + Shift + N. 

  Затем вставьте следующий код - 
/*************************************************
* Public Constants
*************************************************/

#define NOTE_B0 31
#define NOTE_C1 33
#define NOTE_CS1 35
#define NOTE_D1 37
#define NOTE_DS1 39
#define NOTE_E1 41
#define NOTE_F1 44
#define NOTE_FS1 46
#define NOTE_G1 49
#define NOTE_GS1 52
#define NOTE_A1 55
#define NOTE_AS1 58
#define NOTE_B1 62
#define NOTE_C2 65
#define NOTE_CS2 69
#define NOTE_D2 73
#define NOTE_DS2 78
#define NOTE_E2 82
#define NOTE_F2 87
#define NOTE_FS2 93
#define NOTE_G2 98
#define NOTE_GS2 104
#define NOTE_A2 110
#define NOTE_AS2 117
#define NOTE_B2 123
#define NOTE_C3 131
#define NOTE_CS3 139
#define NOTE_D3 147
#define NOTE_DS3 156
#define NOTE_E3 165
#define NOTE_F3 175
#define NOTE_FS3 185
#define NOTE_G3 196
#define NOTE_GS3 208
#define NOTE_A3 220
#define NOTE_AS3 233
#define NOTE_B3 247
#define NOTE_C4 262
#define NOTE_CS4 277
#define NOTE_D4 294
#define NOTE_DS4 311
#define NOTE_E4 330
#define NOTE_F4 349
#define NOTE_FS4 370
#define NOTE_G4 392
#define NOTE_GS4 415
#define NOTE_A4 440
#define NOTE_AS4 466
#define NOTE_B4 494
#define NOTE_C5 523
#define NOTE_CS5 554
#define NOTE_D5 587
#define NOTE_DS5 622
#define NOTE_E5 659
#define NOTE_F5 698
#define NOTE_FS5 740
#define NOTE_G5 784
#define NOTE_GS5 831
#define NOTE_A5 880
#define NOTE_AS5 932
#define NOTE_B5 988
#define NOTE_C6 1047
#define NOTE_CS6 1109
#define NOTE_D6 1175
#define NOTE_DS6 1245
#define NOTE_E6 1319
#define NOTE_F6 1397
#define NOTE_FS6 1480
#define NOTE_G6 1568
#define NOTE_GS6 1661
#define NOTE_A6 1760
#define NOTE_AS6 1865
#define NOTE_B6 1976
#define NOTE_C7 2093
#define NOTE_CS7 2217
#define NOTE_D7 2349
#define NOTE_DS7 2489
#define NOTE_E7 2637
#define NOTE_F7 2794
#define NOTE_FS7 2960
#define NOTE_G7 3136
#define NOTE_GS7 3322
#define NOTE_A7 3520
#define NOTE_AS7 3729
#define NOTE_B7 3951
#define NOTE_C8 4186
#define NOTE_CS8 4435
#define NOTE_D8 4699
#define NOTE_DS8 4978
  Сохраните приведенный выше код как pitches.h 
  Arduino Code 
#include "pitches.h"
// notes in the melody:
int melody[] = {
NOTE_C4, NOTE_G3,NOTE_G3, NOTE_GS3, NOTE_G3,0, NOTE_B3, NOTE_C4};
// note durations: 4 = quarter note, 8 = eighth note, etc.:

int noteDurations[] = {
   4, 8, 8, 4,4,4,4,4 
};

void setup() {
   // iterate over the notes of the melody:
   for (int thisNote = 0; thisNote < 8; thisNote++) {
      // to calculate the note duration, take one second
      // divided by the note type.
      //e.g. quarter note = 1000 / 4, eighth note = 1000/8, etc.
      int noteDuration = 1000/noteDurations[thisNote];
      tone(8, melody[thisNote],noteDuration);
      //pause for the note's duration plus 30 ms:
      delay(noteDuration +30);
   }
}

void loop() {
   // no need to repeat the melody.
}
  Код для заметки 
  Код использует дополнительный файл, pitches.h.  Этот файл содержит все значения высоты звука для типичных нот.  Например, NOTE_C4 - середина C. NOTE_FS4 - F резкое и т. Д.  Эта таблица примечаний была первоначально написана Бреттом Хэгмэном, на работе которого была основана команда tone ().  Вы можете найти это полезным, когда вы хотите сделать музыкальные ноты. 
  Результат 
  Вы услышите музыкальные ноты, сохраненные в pitches.h.  файл. 
  Arduino - беспроводная связь 
  Модули беспроводного передатчика и приемника работают на частоте 315 МГц.  Они могут легко вписаться в макет и хорошо работать с микроконтроллерами, создавая очень простой беспроводной канал передачи данных.  С одной парой передатчик и приемник модули будут работать только для передачи данных в одностороннем порядке, однако вам потребуется две пары (разных частот), чтобы действовать как пара передатчик / приемник. 
  Примечание. Эти модули являются неизбирательными и получают значительное количество шума.  И передатчик, и приемник работают на общих частотах и ​​не имеют идентификаторов. 

  Технические характеристики приемного модуля 

  Модель продукта - MX-05V 
  Рабочее напряжение - DC5V 
  Ток покоя - 4 мА 
  Частота приема - 315 МГц 
  Чувствительность приемника - -105DB 
  Размер - 30 * 14 * 7 мм 

  Технические характеристики модуля передатчика 

  Модель продукта - MX-FS-03V 
  Стартовая дистанция - 20-200 метров (разное напряжение, разные результаты) 
  Рабочее напряжение - 3,5-12 В 
  Размеры - 19 * 19 мм 
  Режим работы - AM 
  Скорость передачи - 4 КБ / с 
  Мощность передачи - 10 мВт 
  Частота передачи - 315 МГц 
  Внешняя антенна - обычная многоядерная или одноядерная линия 25см 
  Распиновка слева → справа - (ДАННЫЕ; V CC ; GND) 

  Необходимые компоненты 
  Вам понадобятся следующие компоненты - 

  2 × доска Arduino UNO 
  Передатчик 1 х РЧ 
  1 × РЧ-приемник 

  Процедура 
  Следуйте электрической схеме и выполните соединения, как показано на рисунке ниже. 

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

  Примечание. Вы должны включить библиотеку клавиатуры в свой файл библиотеки Arduino.  Скопируйте и вставьте файл VirtualWire.lib в папку библиотек, как показано на приведенном ниже снимке экрана. 

  Arduino код для передатчика 
//simple Tx on pin D12
#include <VirtualWire.h>
char *controller;

void setup() {
   pinMode(13,OUTPUT);
   vw_set_ptt_inverted(true);
   vw_set_tx_pin(12);
   vw_setup(4000);// speed of data transfer Kbps
}

void loop() {
   controller="1" ;
   vw_send((uint8_t *)controller, strlen(controller));
   vw_wait_tx(); // Wait until the whole message is gone
   digitalWrite(13,1);
   delay(2000);
   controller="0" ;
   vw_send((uint8_t *)controller, strlen(controller));
   vw_wait_tx(); // Wait until the whole message is gone
   digitalWrite(13,0);
   delay(2000);
}
  Код для заметки 
  Это простой код.  Сначала он отправит символ «1», а через две секунды он отправит символ «0» и так далее. 
  Arduino код для приемника 
//simple Rx on pin D12
#include <VirtualWire.h>

void setup() {
   vw_set_ptt_inverted(true); // Required for DR3100
   vw_set_rx_pin(12);
   vw_setup(4000); // Bits per sec
   pinMode(5, OUTPUT);
   vw_rx_start(); // Start the receiver PLL running
}

void loop() {
   uint8_t buf[VW_MAX_MESSAGE_LEN];
   uint8_t buflen = VW_MAX_MESSAGE_LEN;
   if (vw_get_message(buf, &buflen)) // Non-blocking {
      if(buf[0]=='1') {
         digitalWrite(5,1);
      }
      if(buf[0]=='0') {
         digitalWrite(5,0);
      }
   }
}
  Код для заметки 
  Светодиод, подключенный к контакту № 5 на плате Arduino, включается при получении символа «1» и выключается при получении символа «0». 
  Arduino - Сетевые коммуникации 
  WiFi-модуль CC3000 от Texas Instruments представляет собой небольшую серебристую упаковку, которая, наконец, обеспечивает простую в использовании и доступную WiFi-функциональность для ваших проектов Arduino. 
  Он использует SPI для связи (не UART!), Поэтому вы можете передавать данные так быстро, как вы хотите, или так медленно, как вы хотите.  Он имеет правильную систему прерываний с выводом IRQ, поэтому вы можете иметь асинхронные соединения.  Он поддерживает 802.11b / g, открытый / WEP / WPA / WPA2 безопасность, TKIP & AES.  Встроенный стек TCP / IP с интерфейсом «BSD socket» поддерживает TCP и UDP как в режиме клиента, так и в режиме сервера. 

  Необходимые компоненты 
  Вам понадобятся следующие компоненты - 

  1 × Arduino Uno 
  1 × Adafruit CC3000 разделочная доска 
  1 × 5 В реле 
  1 × Выпрямительный диод 
  1 × светодиод 
  Резистор 1 × 220 Ом 
  1 × макет и некоторые перемычки 

  Для этого проекта вам просто понадобится обычная среда разработки Arduino, библиотека Adafruit CC3000 и библиотека CC3000 MDNS.  Мы также собираемся использовать библиотеку aREST для отправки команд на реле через WiFi. 
  Процедура 
  Следуйте электрической схеме и выполните соединения, как показано на рисунке ниже. 

  Конфигурация оборудования для этого проекта очень проста. 

  Подключите вывод IRQ платы CC3000 к выводу № 3 платы Arduino. 
  VBAT для вывода 5 и CS для вывода 10. 
  Подключите контакты SPI к плате Arduino: MOSI, MISO и CLK к контактам 11, 12 и 13 соответственно. 
  V in подключен к Arduino 5V, а GND - к GND. 

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

  Сначала подключите контакт № 8 платы Arduino к одному контакту катушки. 
  Подключите другой штырь к заземлению платы Arduino. 

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


  Подключите + 5В платы Arduino к общему контакту переключателя реле. 


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


  Подключите + 5В платы Arduino к общему контакту переключателя реле. 
  Наконец, подключите один из другого контакта переключателя (обычно тот, который не подключен, когда реле выключено) к светодиоду последовательно с резистором 220 Ом, и подключите другую сторону светодиода к заземлению Arduino. доска. 
  Тестирование отдельных компонентов 
  Вы можете проверить реле со следующим эскизом - 
const int relay_pin = 8; // Relay pin

void setup() {
   Serial.begin(9600);
   pinMode(relay_pin,OUTPUT);
}

void loop() {
   // Activate relay
   digitalWrite(relay_pin, HIGH);
   // Wait for 1 second
   delay(1000);
   // Deactivate relay
   digitalWrite(relay_pin, LOW);
   // Wait for 1 second
   delay(1000);
}
  Код для заметки 
  Код не требует пояснений.  Вы можете просто загрузить его на плату, и реле будет переключать состояния каждую секунду, а светодиод будет включаться и выключаться соответственно. 
  Добавление Wi-Fi подключения 
  Давайте теперь управлять реле по беспроводной сети с помощью WiFi-чипа CC3000.  Программное обеспечение для этого проекта основано на протоколе TCP.  Однако для этого проекта на плате Arduino будет работать небольшой веб-сервер, поэтому мы можем «прослушивать» команды, поступающие с компьютера.  Сначала мы позаботимся о наброске Arduino, а затем посмотрим, как написать код на стороне сервера и создать красивый интерфейс. 
  Во-первых, эскиз Arduino.  Цель здесь - подключиться к вашей сети Wi-Fi, создать веб-сервер, проверить наличие входящих TCP-подключений, а затем соответствующим образом изменить состояние реле. 
  Важные части Кодекса 
#include <Adafruit_CC3000.h>
#include <SPI.h>
#include <CC3000_MDNS.h>
#include <Ethernet.h>
#include <aREST.h>
  Вы должны определить внутри кода, что является специфическим для вашей конфигурации, то есть имя и пароль Wi-Fi, а также порт для связи по TCP (здесь мы использовали 80). 
// WiFi network (change with your settings!)
   #define WLAN_SSID "yourNetwork" // cannot be longer than 32 characters!
   #define WLAN_PASS "yourPassword"
   #define WLAN_SECURITY WLAN_SEC_WPA2 // This can be WLAN_SEC_UNSEC, WLAN_SEC_WEP, 
   // WLAN_SEC_WPA or WLAN_SEC_WPA2

// The port to listen for incoming TCP connections
   #define LISTEN_PORT 80
  Затем мы можем создать экземпляр CC3000, сервер и экземпляр aREST - 
// Server instance
   Adafruit_CC3000_Server restServer(LISTEN_PORT); // DNS responder instance
   MDNSResponder mdns; // Create aREST instance
   aREST rest = aREST();
  В части скриншота setup () теперь мы можем подключить чип CC3000 к сети - 
cc3000.connectToAP(WLAN_SSID, WLAN_PASS, WLAN_SECURITY);

  Как компьютер узнает, куда отправлять данные?  Один из способов - запустить эскиз один раз, затем получить IP-адрес платы CC3000 и снова изменить код сервера.  Тем не менее, мы можем добиться большего, и именно здесь в игру вступает библиотека CC3000 MDNS.  Мы назначим фиксированное имя для нашей платы CC3000 с этой библиотекой, чтобы мы могли записать это имя непосредственно в код сервера. 
  Это делается с помощью следующего фрагмента кода: 
if (!mdns.begin("arduino", cc3000)) {
   while(1);
}
  Нам также нужно прослушивать входящие соединения. 
restServer.begin();

  Далее мы закодируем функцию loop () эскиза, которая будет выполняться непрерывно.  Сначала мы должны обновить сервер mDNS. 
mdns.update();

  Сервер, работающий на плате Arduino, будет ожидать входящих соединений и обрабатывать запросы. 
Adafruit_CC3000_ClientRef client = restServer.available();
rest.handle(client);

  Теперь тестировать проекты через WiFi довольно просто.  Убедитесь, что вы обновили скетч со своим собственным именем и паролем Wi-Fi, и загрузите скетч на свою плату Arduino.  Откройте серийный монитор Arduino IDE и найдите IP-адрес своей платы. 
  Для остальных предположим, что это что-то вроде 192.168.1.103. 
  Затем просто перейдите в ваш любимый веб-браузер и введите - 
  192.168.1.103/digital/8/1 
  Вы должны увидеть, что ваше реле автоматически включается. 
  Построение интерфейса реле 
  Теперь мы будем кодировать интерфейс проекта.  Здесь будет две части: файл HTML, содержащий интерфейс, и файл Javascript на стороне клиента, чтобы обрабатывать щелчки на интерфейсе.  Интерфейс здесь основан на проекте aREST.js , который был создан для простого управления устройствами WiFi с вашего компьютера. 
  Давайте сначала посмотрим файл HTML, который называется interface.html.  Первая часть состоит из импорта всех необходимых библиотек для интерфейса - 
<head>
   <meta charset = utf-8 />
   <title> Relay Control </title>
   <link rel = "stylesheet" type = "text/css" 
      href = "https://maxcdn.bootstrapcdn.com/bootstrap/3.3.4/css/bootstrap.min.css">
   <link rel="stylesheet" type = "text/css" href = "style.css">
   <script type = "text/javascript" 
      src = "https://code.jquery.com/jquery-2.1.4.min.js"></script>
   <script type = "text/javascript" 
      src = "https://cdn.rawgit.com/Foliotek/AjaxQ/master/ajaxq.js"></script>
   <script type = "text/javascript" 
      src = "https://cdn.rawgit.com/marcoschwartz/aREST.js/master/aREST.js"></script>
   <script type = "text/javascript" 
      src = "script.js"></script>
</head>
  Затем мы определяем две кнопки внутри интерфейса: одну для включения реле, а другую для его повторного выключения. 
<div class = 'container'>
   <h1>Relay Control</h1>
   <div class = 'row'>
      <div class = "col-md-1">Relay</div>
      <div class = "col-md-2">
         <button id = 'on' class = 'btn btn-block btn-success'>On</button>
      </div>
      <div class = "col-md-2">
         <button id = 'off' class = 'btn btn-block btn-danger'>On</button>
      </div>
   </div>
</div>

  Теперь нам также нужен Javascript-файл на стороне клиента для обработки нажатий на кнопки.  Мы также создадим устройство, которое мы свяжем с именем mDNS нашего устройства Arduino.  Если вы изменили это в коде Arduino, вам нужно будет изменить и его здесь. 
// Create device
var device = new Device("arduino.local");
// Button

$('#on').click(function() {
   device.digitalWrite(8, 1);
});

$('#off').click(function() {
   device.digitalWrite(8, 0);
});

  Полный код этого проекта можно найти в репозитории GitHub .  Перейдите в папку интерфейса и просто откройте файл HTML в своем любимом браузере.  Вы должны увидеть нечто подобное в вашем браузере - 

  Попробуйте нажать кнопку в веб-интерфейсе;  это должно изменить состояние реле почти мгновенно. 
  Если вам удалось заставить его работать, браво!  Вы только что создали Wi-Fi-управляемый выключатель света.  Конечно, вы можете контролировать гораздо больше, чем свет с этим проектом.  Просто убедитесь, что ваше реле поддерживает питание, необходимое для устройства, которым вы хотите управлять, и вы готовы к работе.