Функция arduino serial begin

Step 7: Command : Print()

Description

Prints data to the serial port as human-readable ASCII text. This command can take many forms. Numbers are printed using an ASCII character for each digit. Floats are similarly printed as ASCII digits, defaulting to two decimal places. Bytes are sent as a single character. Characters and strings are sent as is. For example:

Serial.print(78) gives «78» Serial.print(1.23456) gives «1.23» Serial.print(‘N’) gives «N» Serial.print(«Hello world.») gives «Hello world.» An optional second parameter specifies the base (format) to use; permitted values are BIN (binary, or base 2), OCT (octal, or base 8), DEC (decimal, or base 10), HEX (hexadecimal, or base 16). For floating point numbers, this parameter specifies the number of decimal places to use. For example:

Serial.print(78, BIN) gives «1001110» Serial.print(78, OCT) gives «116» Serial.print(78, DEC) gives «78» Serial.print(78, HEX) gives «4E» Serial.println(1.23456, 0) gives «1» Serial.println(1.23456, 2) gives «1.23» Serial.println(1.23456, 4) gives «1.2346» You can pass flash-memory based strings to Serial.print() by wrapping them with F(). For example :

Serial.print(F(“Hello World”)) To send a single byte, use Serial.write().

Syntax

Serial.print(val) Serial.print(val, format)

Parameters

val: the value to print — any data type

format: specifies the number base (for integral data types) or number of decimal places (for floating point types)

Returns

size_t (long): print() returns the number of bytes written, though reading that number is optional

Example:

/*

Uses a FOR loop for data and prints a number in various formats.

*/

int x = 0; // variable

void setup() {

Serial.begin(9600); // open the serial port at 9600 bps:

}

void loop() {

// print labels

Serial.print(«NO FORMAT»); // prints a label

Serial.print(«\t»); // prints a tab

Serial.print(«DEC»);

Serial.print(«\t»);

Serial.print(«HEX»);

Serial.print(«\t»);

Serial.print(«OCT»);

Serial.print(«\t»);

Serial.print(«BIN»);

Serial.print(«\t»);

for(x=0; x< 64; x++){ // only part of the ASCII chart, change to suit

// print it out in many formats:

Serial.print(x); // print as an ASCII-encoded decimal — same as «DEC»

Serial.print(«\t»); // prints a tab

Serial.print(x, DEC); // print as an ASCII-encoded decimal

Serial.print(«\t»); // prints a tab

Serial.print(x, HEX); // print as an ASCII-encoded hexadecimal

Serial.print(«\t»); // prints a tab

Serial.print(x, OCT); // print as an ASCII-encoded octal

Serial.print(«\t»); // prints a tab

Serial.println(x, BIN); // print as an ASCII-encoded binary

// then adds the carriage return with «println»

delay(200); // delay 200 milliseconds

}

Serial.println(«»); // prints another carriage return

}

Функция println и отличия от print

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

Метод println () класса Serial выполняет ту же функцию, что и print() – он выводит в последовательный порт ASCII-текст.  Аргументы у методов тоже совпадают – мы передаем текст или число с возможным вторым аргументом, определяющим формат. Отличие же println заключается в принудительном добавлении в конце передающейся строки символа новой строки “\r” (ASCII код 13). Суффикс ln обозначает сокращенное слово line (строка). Используя println, мы можем быть уверены, что следующая (но не текущая) строка будет выведена с новой строки.

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

Serial.println(“Line number  1”);
Serial.println(“Line number  2”);
Serial.println(“Line number  3”);

При формировании строки мы также можем использовать следующие специальные символы: “\0”, “\r”, “\t” (символ табуляции). Табулирование позволяет печатать на экране что-то типа таблицы значений:

Serial.print("Column1\t\t");
Serial.println("Column2");
Serial.print("Cell 11\t\t");
Serial.println("Cel l2");
Serial.print("Cell 21\t\t");
Serial.println("Cel 22");

Функции Serial.find() и Serial.findUntil()

Функция Serial.find() считывает содержимое буфера в поисках конкретной строки. Функция возвращает true, когда строка найдена и false, когда данные не найдены. Ниже приведен пример кода программы:

void setup()
{
Serial.begin(9600);
}
void loop()
{
if(Serial.find(«test»)) Serial.println(«ok.»);
}

В данном примере программа считывает данные из буфера и когда полученные данные соответствуют строке поиска (test), то отображается сообщение (ok).

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

Serial.findUntil() — это вариант Serial.find(), который отличается от предшественника дополнительным аргументом, позволяющим прервать загрузку буфера последовательного порта. Пример синтаксиса показан ниже:

Serial.findUntil ( «text», «K»);

Функция будет считывать данные из последовательного порта, пока не будет найдена строка поиска (text) или прочитан символ «K», или пока не пройдет определенное время (по умолчанию – 1 секунда).

Step 8: Command : Println()

Description

Prints data to the serial port as human-readable ASCII text followed by a carriage return character (ASCII 13, or ‘\r’) and a newline character (ASCII 10, or ‘\n’). This command takes the same forms as Serial.print().

Syntax

Serial.println(val) Serial.println(val, format)

Parameters

val: the value to print — any data type

format: specifies the number base (for integral data types) or number of decimal places (for floating point types)

Returns

size_t (long): println() returns the number of bytes written, though reading that number is optional

Example:

/*

Analog input

reads an analog input on analog in 0, prints the value out.

created 24 March 2006

by Tom Igoe

*/

int analogValue = 0; // variable to hold the analog value

void setup() {

// open the serial port at 9600 bps:

Serial.begin(9600);

}

void loop() {

// read the analog input on pin 0:

analogValue = analogRead(0);

// print it out in many formats:

Serial.println(analogValue); // print as an ASCII-encoded decimal

Serial.println(analogValue, DEC); // print as an ASCII-encoded decimal

Serial.println(analogValue, HEX); // print as an ASCII-encoded hexadecimal

Serial.println(analogValue, OCT); // print as an ASCII-encoded octal

Serial.println(analogValue, BIN); // print as an ASCII-encoded binary

// delay 10 milliseconds before the next reading:

delay(10);

}

Функция Serial.write()

В отличие от Serial.print() и Serial.println(), функция Serial.write() позволяет отправлять один байт информации (число). Ниже приведен синтаксис Serial.write():

Serial.write (число);
Serial.write («текст»);
Serial.write (массив, длина);

Примеры использования Serial.write():

byte a[]={65,66,67,68,69};
void setup()
{
Serial.begin(9600);
}
void loop()
{
Serial.print(65); // отправляет в терминал два символа 6 и 5
Serial.write(65); // отправляет в терминал код 65 (буква A в кодировке ASCII)
Serial.write(a,3); // отправляет в терминал коды 65, 66, 67 (A, B, C)
delay(800);
}

Как вы можете видеть в данном примере, при отправке числа 65 с помощью Serial.print() в терминале получим два символа 6 и 5, а отправка числа 65 с использованием Serial.write() в терминале будет интерпретироваться как код ASCII 65, т.е «А».

print()

Description

Prints data to the serial port as human-readable ASCII text. This command can take many forms. Numbers are printed using an ASCII character for each digit. Floats are similarly printed as ASCII digits, defaulting to two decimal places. Bytes are sent as a single character. Characters and strings are sent as is. For example:

• Serial.print(78) gives «78»
• Serial.print(1.23456) gives «1.23»
• Serial.print(‘N’) gives «N»
• Serial.print(«Hello world.») gives «Hello world.»

An optional second parameter specifies the base (format) to use; permitted values are BIN (binary, or base 2), OCT (octal, or base 8), DEC (decimal, or base 10), HEX (hexadecimal, or base 16). For floating point numbers, this parameter specifies the number of decimal places to use. For example:

• Serial.print(78, BIN) gives «1001110»
• Serial.print(78, OCT) gives «116»
• Serial.print(78, DEC) gives «78»
• Serial.print(78, HEX) gives «4E»
• Serial.println(1.23456, 0) gives «1»
• Serial.println(1.23456, 2) gives «1.23»
• Serial.println(1.23456, 4) gives «1.2346»

You can pass flash-memory based strings to Serial.print() by wrapping them with F(). For example :

Serial.print(F(“Hello World”))

To send a single byte, use Serial.write().

Parameters

val: the value to print — any data type

format: specifies the number base (for integral data types) or number of decimal places (for floating point types)

Example:

/*
Uses a FOR loop for data and prints a number in various formats.
*/int x = ;    // variablevoid setup() {
  Serial.begin(9600);      // open the serial port at 9600 bps:    }void loop() {  
  // print labels
  Serial.print(«NO FORMAT»);       // prints a label
  Serial.print(«\t»);              // prints a tab
  Serial.print(«DEC»);  
  Serial.print(«\t»);      
  Serial.print(«HEX»);
  Serial.print(«\t»);  
  Serial.print(«OCT»);
  Serial.print(«\t»);
  Serial.print(«BIN»);
  Serial.print(«\t»);
  for(x=; x< 64; x++){    // only part of the ASCII chart, change to suit
    // print it out in many formats:
    Serial.print(x);       // print as an ASCII-encoded decimal — same as «DEC»
    Serial.print(«\t»);    // prints a tab
    Serial.print(x, DEC);  // print as an ASCII-encoded decimal
    Serial.print(«\t»);    // prints a tab
    Serial.print(x, HEX);  // print as an ASCII-encoded hexadecimal
    Serial.print(«\t»);    // prints a tab
    Serial.print(x, OCT);  // print as an ASCII-encoded octal
    Serial.print(«\t»);    // prints a tab
    Serial.println(x, BIN);  // print as an ASCII-encoded binary
    //                             then adds the carriage return with «println»
    delay(200);            // delay 200 milliseconds
  }
  Serial.println(«»);      // prints another carriage return}

Programming Tips

As of version 1.0, serial transmission is asynchronous; Serial.print() will return before any characters are transmitted.

Прием и отправка текста на монитор порта

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

Пример 1. Команды для вывода текста

void setup()
{
  Serial.begin(9600);    // подключаем монитор порта
  Serial.print("Start"); // выводим текст на монитор 1 раз
}

void loop()
{
  Serial.print("Hello!"); // выводим текст 1 раз в секунду
  delay(1000);            // задержка в 1 секунду
}

Пример 2. Команды с переносом строки

void setup()
{
  Serial.begin(9600);    // подключаем монитор порта
  Serial.println("Start"); // выводим текст на монитор 1 раз
}

void loop()
{
  Serial.println("Hello!"); // выводим текст 1 раз в секунду
  delay(1000);              // задержка в 1 секунду
}

Пример 3. Вывод переменных на монитор порта

void setup()
{
  Serial.begin(9600);    // подключаем монитор порта
  Serial.println("Start"); // выводим текст на монитор 1 раз
}

void loop()
{
  byte z;                // освобождаем память для переменной z
  byte x = random(0,10); // генерируем случайное число x
  byte y = random(0,10); // генерируем случайное число y

  z = x + y; // выполняем операцию сложения

  // выводим результаты арифметических операций
  Serial.print(x);
  Serial.print(" + ");
  Serial.print(y);
  Serial.print(" = ");
  Serial.println(z);

  delay(1000); // задержка в 1 секунду
}

Скетч для общения компьютера и Ардуино через Serial Monitor

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

Пример 4. Команды для табуляции и переноса строк

void setup()
{
  Serial.begin(9600);    // подключаем монитор порта
  Serial.println("Start"); // выводим текст на монитор 1 раз
}

void loop()
{
  byte z;                // освобождаем память для переменной z
  byte x = random(0,10); // генерируем случайное число x
  byte y = random(0,10); // генерируем случайное число y

  z = x * y; // выполняем операцию умножения

  // выводим результаты арифметических операций
  Serial.print(x);
  Serial.print("\t"); // табуляция
  Serial.print(y);
  Serial.print("\t"); // табуляция
  Serial.print(z);
  Serial.print("\n"); // перенос строки
  delay(1000); // задержка в 1 секунду
}

Часто в скетчах требуется отключить Serial Monitor или очистить буфер обмена последовательного порта, для этого используется команда , чтобы запустить обмен информацией между Ардуино и компьютером снова выполняется команда , которую можно прописать в процедуре loop. Если у вас выводятся кракозябры и иероглифы, то проверьте скорость передачи данных, установленную в скетче, и в настройках утилиты (правый нижний угол).

Как подключить монитор порта Ардуино правильно, чтобы не выводились квадратики и иероглифы мы разобрались — это команда (скорость обмена данными по умолчанию). Чтобы отправлять данные в последовательный порт с компьютера и управлять Ардуино, используется команда для приема данных и для чтения больших чисел. Использование данных команд на примере можно посмотреть здесь: Управление Ардуино с компьютера.

Функции Serial.print() и Serial.println()

Функция Serial.print() позволяет отправлять информацию через последовательный порт. Можно отправлять как текстовые, так и переменные значения или непосредственно числа. Данные отправляются в кодировке ASCII. Это означает, что число, например, 12, будет отправлено как два символа 1 и 2. Вот типичный синтаксис Serial.print():

Serial.print(78); // число 78
Serial.print(1.23456); // количество 1.23
Serial.print(‘N’); // символ: N
Serial.print(«Hello world.»); // текст: Hello world.
Serial.print(78, BIN); // двоичное число: 1001110
Serial.print(78, OCT); // исходное восьмеричное число: 116
Serial.print(78, DEC); // десятичное число: 78
Serial.print(78, HEX); // шестнадцатеричное число: 4E
Serial.println(1.23456, 0); // первая цифра: 1
Serial.println(1.23456, 2); // три первые цифры: 1.23

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

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

Serial.print(‘A’);
Serial.print(‘B’);
Serial.println(‘C’); // ABC
Serial.print(‘D’); // DE
Serial.println(‘E’); // F
Serial.println(‘F’); // G
Serial.print(‘G’);

Step 1: Command : If (Serial)

Description

Indicates if the specified Serial port is ready.

On 32u4 based boards (Leonardo, Yùn, ecc) , if (Serial) indicates whether or not the USB CDC serial connection is open. For all other instances, including if (Serial1) on the Leonardo, this will always return true.

This was introduced in Arduino 1.0.1.

Syntax

All boards: if (Serial)

Arduino Leonardo specific: if (Serial1)

Arduino Mega specific: if (Serial1) if (Serial2) if (Serial3)

Parameters

none

Returns

boolean : Returns true if the specified serial port is available. This will only return false if querying the Leonardo’s USB CDC serial connection before it is ready.

Example:

void setup() {

//Initialize serial and wait for port to open:

Serial.begin(9600);

while (!Serial) {

; // wait for serial port to connect. Needed for native USB

}

}

void loop() {

//proceed normally

}

Функция Serial.read()

Данные из буфера последовательного порта считываются при помощи функции Serial.read(). Она извлекает один байт данных, уменьшая количество доступной информации в буфере. Ниже приведен пример использования Serial.read():

void setup()
{
Serial.begin(9600);
}
void loop()
{
if(Serial.available())
{
byte kol = Serial.read(); //чтение количества
Serial.println(kol);
//————————————————-
char znak=Serial.read(); //чтение кода символа
Serial.println(znak);
}
delay(80);
}

Вышеуказанная программа считывает данные из последовательного порта и отправляет их на терминал. Существует два способа интерпретации данных. В первом случае байт, считанный с порта, рассматривается как число. Терминал отобразит соответствующий символ ASCII, во втором случае прочитанный байт рассматривается как код ASCII. Когда вы запустите программу и введете букву «a» в первом случае, вы получите код «97», а во втором букву «a».

Analog Read Serial

This example shows you how to read analog input from the physical world using a potentiometer. A potentiometer is a simple mechanical device that provides a varying amount of resistance when its shaft is turned. By passing voltage through a potentiometer and into an analog input on your board, it is possible to measure the amount of resistance produced by a potentiometer (or pot for short) as an analog value. In this example you will monitor the state of your potentiometer after establishing serial communication between your Arduino or Genuino and your computer running the Arduino Software (IDE).

Circuit

Connect the three wires from the potentiometer to your board. The first goes from one of the outer pins of the potentiometerto ground . The second goes from the other outer pin of the potentiometer to 5 volts. The third goes from the middle pin of the potentiometer to the analog pin A0.

By turning the shaft of the potentiometer, you change the amount of resistance on either side of the wiper, which is connected to the center pin of the potentiometer. This changes the voltage at the center pin. When the resistance between the center and the side connected to 5 volts is close to zero (and the resistance on the other side is close to 10k ohm), the voltage at the center pin nears 5 volts. When the resistances are reversed, the voltage at the center pin nears 0 volts, or ground. This voltage is the analog voltage that you’re reading as an input.

The Arduino and Genuino boards have a circuit inside called an analog-to-digital converter or ADC that reads this changing voltage and converts it to a number between 0 and 1023. When the shaft is turned all the way in one direction, there are 0 volts going to the pin, and the input value is 0. When the shaft is turned all the way in the opposite direction, there are 5 volts going to the pin and the input value is 1023. In between, analogRead() returns a number between 0 and 1023 that is proportional to the amount of voltage being applied to the pin.

Code

In the sketch below, the only thing that you do in the setup function is to begin serial communications, at 9600 bits of data per second, between your board and your computer with the command:

Next, in the main loop of your code, you need to establish a variable to store the resistance value (which will be between 0 and 1023, perfect for an datatype) coming in from your potentiometer:

Finally, you need to print this information to your serial monitor window. You can do this with the command Serial.println() in your last line of code:

Now, when you open your Serial Monitor in the Arduino Software (IDE) (by clicking the icon that looks like a lens, on the right, in the green top bar or using the keyboard shortcut Ctrl+Shift+M), you should see a steady stream of numbers ranging from 0-1023, correlating to the position of the pot. As you turn your potentiometer, these numbers will respond almost instantly.

See Also:

• setup()
• loop()
• analogRead()
• int

• serial

• BareMinimum — The bare minimum of code needed to start an Arduino sketch.
• Blink — Turn an LED on and off.
• DigitalReadSerial — Read a switch, print the state out to the Arduino Serial Monitor.
• Fade — Demonstrates the use of analog output to fade an LED.

Last revision 2015/07/28 by SM

Функция Serial.available()

Функция Serial.available() позволяет проверить, можно ли прочитать данные из последовательного порта. Arduino имеет 64-байтовый буфер последовательного порта. Функция вызывается без параметров, возвращает количество доступных для чтения байт. Serial.available() позволяет исполнить часть программы, которая считывает данные из последовательного порта только при их появлении. Примеры использования Serial.available():

if(Serial.available())
{
//выполнить, если имеются данные
}
———————————————————
while(!Serial.available()); // ждать данные с последовательного порта

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

Во втором примере программа будет остановлена ​​до тех пор, пока в буфере не появляться данные, прочитанные из последовательного порта. Ниже приведено практическое использование Serial.available():

void setup()
{
Serial.begin(9600);
}
void loop()
{
if(Serial.available())
{
int x=Serial.available();
Serial.println(x);
}
delay(80);
}

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

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

Монитор порта

Как мы с вами знаем из урока “О платформе“, на платах Ардуино стоит USB-TTL конвертер, позволяющий микроконтроллеру в текстовом режиме “консоли” общаться с компьютером по последовательному интерфейсу, Serial. На компьютере создаётся виртуальный COM порт, к которому можно подключиться при помощи программ-терминалов порта, и принимать-отправлять текстовые данные. Через этот же порт загружается прошивка, т.к. поддержка Serial является встроенной в микроконтроллер на “железном” уровне, и USB-TTL преобразователь подключен именно к этим выводам микроконтроллера. На плате Arduino Nano это кстати пины D0 и D1.

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

В самой Arduino IDE тоже есть встроенная “консоль” – монитор порта, кнопка с иконкой лупы в правом верхнем углу программы. Нажав на эту кнопку мы откроем сам монитор порта, в котором будут настройки:

Если с отправкой, автопрокруткой, отметками времени и кнопкой “очистить вывод” всё понятно, то конец строки и скорость мы рассмотрим подробнее:

Конец строки: тут есть несколько вариантов на выбор, чуть позже вы поймёте, на что они влияют. Лучше поставить нет конца строки, так как это позволит избежать непонятных ошибок на первых этапах знакомства с Ардуино.

• Нет конца строки – никаких дополнительных символов в конце введённых символов после нажатия на кнопку отправка/Enter
• NL – символ переноса строки в конце отправленных данных
• CR – символ возврата каретки в конце отправленных данных
• NL+CR – и то и то

Скорость – тут на выбор нам даётся целый список скоростей, т.к. общение по Serial может осуществляться на разных скоростях, измеряемых в бод (baud), и если скорости приёма и отправки не совпадают – данные будут получены некорректно. По умолчанию скорость стоит 9600, её и оставим.

Очистить вывод – тут всё понятно, очищает вывод

Пример скетча для print и println

В завершении давайте рассмотрим реальный скетч, в котором мы используем монитор порта Arduino IDE для вывода отладочной информации с платы контроллера.

void setup() {

  // Объявляем работу с последоватлеьным портом в самом начале
  Serial.begin(9600);
  // Теперь мы можем писать сообщения
  Serial.println ("Hello, Arduino Master");
}

void loop() {

  // Выводим таблицу с информацией о текущих значениях портов
  Serial.print("Port #\t\t");
  Serial.println("Value");
  Serial.print("A0\t\t");
  Serial.println(analogRead(A0));
  Serial.print("A1\t\t");
  Serial.println(analogRead(A1));
  Serial.println("--------");
  delay(1000);
}

Функция Serial.setTimeout()

Функция Serial.setTimeout() позволяет задать время ожидания данных из последовательного порта для Serial.readBytes() и Serial.readBytesUntil(). По умолчанию установлено 1000 мс (1 сек).

Serial.setTimeout(время) // время в миллисекундах (тип long)

Ниже приведен пример использования Serial.readBytes(), Serial.readBytesUntil() и Serial.setTimeout():

void setup()
{
char buf;
Serial.begin(9600);
Serial.setTimeout(10000); // лимит времени 10 секунд
while(!Serial.available()); // ждать данные из порта
Serial.println(«Start»);
int x=Serial.readBytes(buf,4); // считать 4 байта
Serial.print(«Polucheno simvolov: «);
Serial.println(x);

while(!Serial.available());
Serial.println(«Start «);
x=Serial.readBytesUntil(‘X’,buf,4); // считать 4 байта
Serial.print(«Polucheno simvolov: «);
Serial.println(x);
}
void loop(){}

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

Digital Read Serial

This example shows you how to monitor the state of a switch by establishing serial communication between your Arduino or Genuino and your computer over USB.

Circuit

Connect three wires to the board. The first two, red and black, connect to the two long vertical rows on the side of the breadboard to provide access to the 5 volt supply and ground. The third wire goes from digital pin 2 to one leg of the pushbutton. That same leg of the button connects through a pull-down resistor (here 10k ohm) to ground. The other leg of the button connects to the 5 volt supply.

Pushbuttons or switches connect two points in a circuit when you press them. When the pushbutton is open (unpressed) there is no connection between the two legs of the pushbutton, so the pin is connected to ground (through the pull-down resistor) and reads as LOW, or 0. When the button is closed (pressed), it makes a connection between its two legs, connecting the pin to 5 volts, so that the pin reads as HIGH, or 1.

If you disconnect the digital i/o pin from everything, the LED may blink erratically. This is because the input is «floating» — that is, it doesn’t have a solid connection to voltage or ground, and it will randomly return either HIGH or LOW. That’s why you need a pull-down resistor in the circuit.

Code

In the program below, the very first thing that you do will in the setup function is to begin serial communications, at 9600 bits of data per second, between your board and your computer with the line:

Next, initialize digital pin 2, the pin that will read the output from your button, as an input:

Now that your setup has been completed, move into the main loop of your code. When your button is pressed, 5 volts will freely flow through your circuit, and when it is not pressed, the input pin will be connected to ground through the 10k ohm resistor. This is a digital input, meaning that the switch can only be in either an on state (seen by your Arduino as a «1», or HIGH) or an off state (seen by your Arduino as a «0», or LOW), with nothing in between.

The first thing you need to do in the main loop of your program is to establish a variable to hold the information coming in from your switch. Since the information coming in from the switch will be either a «1» or a «0», you can use an datatype. Call this variable , and set it to equal whatever is being read on digital pin 2. You can accomplish all this with just one line of code:

Once the board has read the input, make it print this information back to the computer as a decimal value. You can do this with the command Serial.println() in our last line of code:

Now, when you open your Serial Monitor in the Arduino Software (IDE), you will see a stream of «0»s if your switch is open, or «1»s if your switch is closed.

See Also:

• setup()
• loop()
• pinMode()
• digitalRead()
• delay()
• int
• serial

• DigitalPins

• AnalogReadSerial — Read a potentiometer, print its state out to the Arduino Serial Monitor.
• BareMinimum — The bare minimum of code needed to start an Arduino sketch.
• Blink — Turn an LED on and off.
• Fade — Demonstrates the use of analog output to fade an LED.
• ReadAnalogVoltage — Reads an analog input and prints the voltage to the serial monitor.

Last revision 2015/07/29 by SM

MultiSerialMega

Sometimes, one serial port just isn’t enough! When trying to communicate with multiple serial enabled devices, while also sending info back to the main serial window, a few extra RX/TX ports can be a welcomed thing. This example makes use of one of Arduino and Genuino Mega’s 3 auxiliary serial ports, routing any incoming data read on that connection straight to the main TX line, and, in turn, to the main serial window for you to view.

Hardware Required

• Arduino or Genuino Mega Board
• Serial enabled device (a Xbee Radio, a Bluetooth module, or RFID reader, or another board, for instance).

Circuit

After checking the data sheet of whatever serial enabled device you choose to use for this example, make sure that it is both properly wired and powered. Connect the RX pin and TX pins of your device to the TX1 and RX1 pins of your Mega, as shown in the schematic below.

Make sure that your Mega is connected to your computer, via USB, to enable serial communication.

Code

This sketch assumes that you connect your serial enabled device is attached to TX1 and RX1.

/*
  Multiple Serial test
  Receives from the main serial port, sends to the others.
  Receives from serial port 1, sends to the main serial (Serial 0).
  This example works only with boards with more than one serial like Arduino Mega, Due, Zero etc.
  The circuit:
  — any serial device attached to Serial port 1
  — Serial Monitor open on Serial port 0
  created 30 Dec 2008
  modified 20 May 2012
  by Tom Igoe & Jed Roach
  modified 27 Nov 2015
  by Arturo Guadalupi
  This example code is in the public domain.
*/void setup() {
  // initialize both serial ports:
  Serial.begin(9600);
  Serial1.begin(9600);}void loop() {
  // read from port 1, send to port 0:
  if (Serial1.available()) {
    int inByte = Serial1.read();
    Serial.write(inByte);
  }
  // read from port 0, send to port 1:
  if (Serial.available()) {
    int inByte = Serial.read();
    Serial1.write(inByte);
  }}

See Also

• serial.begin()
• serial.read()
• serial.available()

• if()

• ASCIITable — Demonstrates Arduino’s advanced serial output functions.
• Dimmer — Move the mouse to change the brightness of an LED.
• Graph — Send data to the computer and graph it in Processing.
• Midi — Send MIDI note messages serially.
• PhysicalPixel — Turn a LED on and off by sending data to your board from Processing or Max/MSP.
• ReadASCIIString — Parse a comma-separated string of integers to fade an LED.
• SerialCallResponse — Send multiple variables using a call-and-response (handshaking) method.
• SerialCallResponseASCII — Send multiple variables using a call-and-response (handshaking) method, and ASCII-encode the values before sending.
• SerialEvent — Demonstrates the use of SerialEvent().
• VirtualColorMixer — Send multiple variables from Arduino to your computer and read them in Processing or Max/MSP.

Last revision 2015/07/29 by SM