Вывод в монитор порта через serial print, println, write

Arduino string (c style strings)

For C object Strings an ok place to look is the Arduino c string Reference.

However the above link does not detail the functions available for c-style strings. For that look to a standard reference. This link is good as it orders the functions in the order of most used.

P.S. Have a look at strtok() as this can allow you to process a
command line with multiple commands separated with a delimiter e.g. a
semi-colon — Useful for a more complex serial command decoder.

Comparison of String and c string

The following table shows the difference in memory usage:

Type Flash SRAM
String 3912 248
c string 2076 270
Difference String cf c string +1836 -22

Note: It appears that the String class uses
less SRAM but it, in fact uses the heap and uses more than c string uses
(it is just not easy to measure because it can change all the time as strings are created and destroyed).

Using Class String to control strings is undoubtedly the easiest way
and is very similar to higher level languages such as python but it comes
at a cost — that cost is Flash program memory.

Serial

Класс Serial используется для связи платы Ардуино с компьютером или другими устройствами. Все платы Arduino имеют, по крайней мере, один последовательный порт (также известный как UART или USART): Serial. Он связан с цифровыми выводами 0 (RX) и 1 (TX), а также используется для связи с компьютером через USB. Таким образом, во время использования последовательного порта, выводы 0 и 1 не могут использоваться в качестве цифровых входов или выходов.

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

Arduino Mega имеет три дополнительных последовательных порта: Serial1 с выводами 19 (RX) и 18 (TX), Serial2 с выводами 17 (RX) и 16 (TX), Serial3 с выводами 15 (RX) и 14 (TX). Данные выводы не связаны с преобразователем USB-UART на плате Mega, поэтому, для организации связи с компьютером через эти выводы понадобится дополнительный внешний преобразователь USB-UART. Для связи же с другим внешним устройством, имеющим последовательный TTL-порт, достаточно соединить всего три вывода: вывод TX с выводом RX устройства, вывод RX — с выводом TX устройства, а землю Mega, соответственно, с землей внешнего устройства. (Не подсоединяйте эти выводы к последовательному порту RS232 напрямую, поскольку последний работает с напряжениями +/- 12В и может повредить плату Ардуино.)

Arduino Due имеет три дополнительных последовательных порта с TTL-уровнем 3.3В: Serial1 с выводами 19 (RX) и 18 (TX); Serial2 с выводами 17 (RX) и 16 (TX), Serial3 с выводами 15 (RX) и 14 (TX). Выводы 0 и 1 по-прежнему соединены с соответствующими выводами преобразователя интерфейсов USB-Serial TTL, реализованным на микросхеме ATmega16U2, связанной с отладочным портом USB. Помимо этого, благодаря возможностям микросхем SAM3X, на плате реализована и аппаратная поддержка порта USB, SerialUSB.

В Arduino Leonardo Serial1 используется для связи через последовательный TTL-порт (5В) посредством выводов 0 (RX) и 1 (TX). Serial зарезервировано для USB CDC-связи. Для получения дополнительной информации см. страницы Leonardo — начало работы и описание платы.

Функции

  • if (Serial)
  • available()
  • begin()
  • end()
  • find()
  • findUntil()
  • flush()
  • parseFloat()
  • parseInt()
  • peek()
  • print()
  • println()
  • read()
  • readBytes()
  • readBytesUntil()
  • setTimeout()
  • write()
  • serialEvent()

Примеры

  • ReadASCIIString
  • ASCII Table
  • Dimmer
  • Graph
  • Physical Pixel
  • Virtual Color Mixer
  • Serial Call Response
  • Serial Call Response ASCII

Код

Единственная вещь, которую нужно задать в функции setup() – это последовательная передача данных между Arduino и вашим компьютером (со скоростью 9600 бит в секунду). Это делается с помощью нижеследующей строки кода:

Serial.begin(9600);

Далее перемещаемся к секции главного цикла. Здесь нужно создать переменную, которая будет сохранять значение сопротивления (от 0 до 1023; идеальный вариант для этого случая – тип данных int), идущего от вашего потенциометра:

int sensorValue = analogRead(A0);

Наконец, вам надо отобразить эту информацию в меню «Мониторинг последовательной передачи данных» (Serial Monitor) в виде десятичного (DEC) значения. Это можно сделать при помощи команды Serial.println() в последней строке кода:

Serial.println(sensorValue, DEC)

Теперь, когда вы открыли Serial Monitor в среде разработки Arduino (нажав на кнопку, находящуюся справа от кнопки Upload вверху программы), то должны видеть непрерывный поток цифр, варьирующихся от 0 до 1023 и соответствующих той или иной позиции потенциометра. То есть, стоит повернуть потенциометр, и поток цифр мгновенно отреагирует на это действие новыми изменениями.

 1 /*
 2   Считывание последовательной передачи данных через аналоговый контакт
 3   Считывает входные аналоговые данные от 0-го контакта, отображая результаты в меню Serial Monitor.
 4   Подсоединяем центральный контакт потенциометра к 0-му аналоговому контакту (A0), а крайние (боковые) контакты потенциометра – к «земле» и 5-вольтному контакту.
 5 
 6   Данный пример кода не защищен авторским правом.
 7  */
 8 
 9 // эта функция запускается один раз – при рестарте:
10 void setup() {
11   // инициализируем последовательную передачу данных со скоростью 9600 бит в секунду:
12   Serial.begin(9600);
13 }
14 
15 // этот цикл, запустившись, будет повторятся снова и снова:
16 void loop() {
17   // считываем входные данные на 0-вом аналоговом контакте:
18   int sensorValue = analogRead(A0);
19   // отображаем считанную информацию:
20   Serial.println(sensorValue);
21   delay(1);        // задержка между считываниями – для стабильности программы
22 }

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

Для начала рассмотрим запись в EEPROM Arduino числа больше, чем 255, например число 999. При записи в EEPROM число 999 будет разбиваться на множитель (старший байт) и недостающее число (младший байт), занимая при этом уже две ячейки в энергонезависимой памяти (т.е. 999 = 3×256 + 231). Чтобы вывести сохраненное число на монитор порта, его нужно будет «собрать» с помощью функции .

Скетч. Запись в память EEPROM int, float

#include <EEPROM.h>  // импортируем библиотеку    int num = 999;                      // разбиваем число на 2 байта  byte hi  = highByte(num);   // старший байт  byte low = lowByte(num);  // младший байт    void setup() {    Serial.begin(9600);    // запускаем монитор порта       EEPROM.update(1, hi);     // записываем старший байт в ячейку 1     EEPROM.update(2, low); // записываем младший байт в ячейку 2      delay(1000);      byte val1 = EEPROM.read(1);  // считываем 1 байт по адресу ячейки    byte val2 = EEPROM.read(2);  // считываем 1 байт по адресу ячейки      Serial.println("highByte - "+String(val1));  // выводим старший байт на монитор    Serial.println("lowByte  - "+String(val2));  // выводим младший байт на монитор      int NUM = word(hi, low);       // "собираем" число из байтов    Serial.println("int num  - "+String(NUM));    // выводим полученное число  }    void loop() {  }

Пояснения к коду:

  1. для записи данных в ячейку в программе использована функция , которая перезаписывает ячейку только в случае различия сохраняемых данных с данными в ячейке EEPROM Arduino Uno;
  2. основная проблема с сохранением больших чисел (int, float) в память EEPROM заключается в том, чтобы случайно не перезаписать нужную ячейку новой информацией. Для этого нужно учитывать размер сохраняемых данных в ПЗУ, используя функции и .

Скетч. Запись строк в EEPROM (String)

#include <EEPROM.h>  // импортируем библиотеку    int address = 10;  // адрес первой ячейки для записи    long cod = 8904; // разбиваем телефонный номер на две части  long tel = 2768282;  String email = ""; // сохраняем в строке адрес почты    long COD; // создаём новые переменные для чистоты эксперимента  long TEL;  String EMAIL;    void setup() {    Serial.begin(9600);  // запускаем монитор порта      EEPROM.put(address, cod);      // сохраняем код телефона в памяти Ардуино    address += sizeof(cod);              // узнаем адрес следующей свободной ячейки    EEPROM.put(address, tel);       // сохраняем номер телефона в памяти Ардуино    address += sizeof(tel);                // узнаем адрес следующей свободной ячейки    EEPROM.put(address, email);  // сохраняем электронную почту в памяти      address = 10;  // адрес первой ячейки для чтения      Serial.print("Phone: ");  // выводим телефонный номер на монитор    Serial.print(EEPROM.get(address, COD));    address += sizeof(COD);    Serial.println(EEPROM.get(address, TEL));    address += sizeof(TEL);      Serial.print("Email: ");  // выводим электронную почту на монитор    Serial.println(EEPROM.get(address, EMAIL));  }    void loop() {  }

Пояснения к коду:

  1. перед сохранением новых данных в памяти, следует узнать размер данных, которые были сохранены, чтобы начать запись в новой ячейке;
  2. удалив из кода строчки для записи данных, вы можете каждый раз при запуске программы считывать все сохраненные данные из ПЗУ Ардуино.

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 be printed for integral data types (byte, char, int, long, short, unsigned char, unsigned int, unsigned long, word). The permitted values are:

    • BIN: binary, or base 2

    • OCT: octal, or base 8

    • DEC: decimal, or base 10

    • HEX: hexadecimal, or base 16

  • The number of decimal places to be printed for floating point numbers (double, float).

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.print(1.23456, 0) gives «1»

  • Serial.print(1.23456, 2) gives «1.23»

  • Serial.print(1.23456, 4) gives «1.2345»

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

Serial.print(F(«Hello World»))

Функция 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, т.е «А».

Команды библиотеки EEPROM.h Arduino

EEPROM.read(address)
Считывает один байт из EEPROM Arduino по адресу address
EEPROM.write(address, value)
Записывает один байт со значением value в EEPROM по адресу address
EEPROM.update(address, value)
Аналог функции write(), но новые данные в ячейку записываются только тогда, когда они отличаются от уже записанного. Использование данной функции позволяет продлить жизнь памяти EEPROM.
EEPROM.get(address, data)
Считывает из EEPROM Arduino любой тип данных по адресу address. При этом данные (data) могут быть любого типа, например, int или float.
EEPROM.put(address, data)
Записывает в EEPROM Arduino любой тип данных по адресу address. Функция записывает в ячейку только отличающиеся данные.
EEPROM[address]
Позволяет обращаться с байтами EEPROM Arduino как с массивом. Байты можно считывать и записывать.

Our Serial.read() protocol

Let’s make these the protocol rules that we’ll enforce in our Arduino program.

  • New messages will be read as soon as they arrive
  • Messages will be no longer than 12 bytes
  • Every message will end with a newline character ‘\n’ – which we will call out terminating character

This is a pretty basic protocol, but it will help us with our strategy.

First we need a place to store the incoming bytes from the serial receive buffer – we can use a char array for that. Then we need to check if anything is even available in the serial receive buffer – we can use Serial.available for that. Then we need to actually read in a byte – we can use Serial.read() for that.

Before we put the byte into our char array, we’ll need to check the incoming byte to make sure it is not a terminating character.

  1. Create a character array to store incoming bytes
  2. Check to see if there is anything in the serial receive buffer to be read – Serial.available()
  3. While there is something to be read then…
    • Read in the byte to a temporary variable – Serial.read()
    • Check to see if what we read is part of our message OR a terminating character
    • If it is part of our message, then save it to a character array
    • If it is a terminating character, then output the message and prepare for the next message
    • If the message has exceeded the max message length in the protocol, then stop reading in more bytes and output the message (or doing something else with it)

Объяснение программы для ведомой (Slave) платы Arduino

1. Как и в ведущей плате, первым делом в программе мы должны подключить библиотеку Wire для задействования возможностей протокола I2C и библиотеку для работы с ЖК дисплеем. Также нам необходимо сообщить плате Arduino к каким ее контактам подключен ЖК дисплей.

Arduino

#include<Wire.h>
#include<LiquidCrystal.h>
LiquidCrystal lcd(2, 7, 8, 9, 10, 11);

1
2
3

#include<Wire.h>    
#include<LiquidCrystal.h>      

LiquidCrystallcd(2,7,8,9,10,11);

  1. В функции void setup():

—  мы инициализируем последовательную связь со скоростью 9600 бод/с;

Arduino

Serial.begin(9600);

1 Serial.begin(9600);

— далее мы инициализируем связь по протоколу I2C на контактах A4 и A5

В качестве адреса ведомого мы будем использовать значение 8 – очень важно здесь указать адрес ведомого;. Arduino

Wire.begin(8);

Arduino

Wire.begin(8);

1 Wire.begin(8);

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

Arduino

Wire.onReceive(receiveEvent);
Wire.onRequest(requestEvent);

1
2

Wire.onReceive(receiveEvent);

Wire.onRequest(requestEvent);

— затем мы инициализируем ЖК дисплей для работы в режиме 16х2, отображаем на нем приветственное сообщение и очищаем его экран через 5 секунд.

Arduino

lcd.begin(16,2); //Initilize LCD display
lcd.setCursor(0,0); //Sets Cursor at first line of Display
lcd.print(«Circuit Digest»); //Prints CIRCUIT DIGEST in LCD
lcd
.setCursor(0,1); //Sets Cursor at second line of Display
lcd.print(«I2C 2 ARDUINO»); //Prints I2C ARDUINO in LCD
delay(5000); //Delay for 5 seconds
lcd.clear(); //Clears LCD display

1
2
3
4
5
6
7

lcd.begin(16,2);//Initilize LCD display

lcd.setCursor(,);//Sets Cursor at first line of Display

lcd.print(«Circuit Digest»);//Prints CIRCUIT DIGEST in LCD

lcd.setCursor(,1);//Sets Cursor at second line of Display

lcd.print(«I2C 2 ARDUINO»);//Prints I2C ARDUINO in LCD

delay(5000);//Delay for 5 seconds

lcd.clear();//Clears LCD display

3. Затем нам будут необходимы две функции: одна для события запроса (request event) и одна для события приема (receive event).

Для события запроса:

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

Arduino

void requestEvent()
{
int potvalue = analogRead(A0);
byte SlaveSend = map(potvalue,0,1023,0,127);
Wire.write(SlaveSend);
}

1
2
3
4
5
6

voidrequestEvent()

{

intpotvalue=analogRead(A0);

byteSlaveSend=map(potvalue,,1023,,127);

Wire.write(SlaveSend);

}

Для события приема:

Эта функция будет выполняться когда ведущий будет передавать данные ведомому с адресом 8. Эта функция считывает принятые значения от ведущего и сохраняет ее в переменной типа byte.

Arduino

void receiveEvent (int howMany)
{
SlaveReceived = Wire.read();
}

1
2
3
4

voidreceiveEvent(inthowMany)

{

SlaveReceived=Wire.read();

}

4. В функции Void loop():

Мы будем непрерывно отображать принятые от ведущей платы значения на экране ЖК дисплея.

Arduino

void loop(void)
{
lcd.setCursor(0,0); //Sets Currsor at line one of LCD
lcd.print(«>> Slave <<«); //Prints >> Slave << at LCD
lcd.setCursor(0,1); //Sets Cursor at line two of LCD
lcd.print(«MasterVal:»); //Prints MasterVal: in LCD
lcd.print(SlaveReceived); //Prints SlaveReceived value in LCD received from Master
Serial.println(«Slave Received From Master:»); //Prints in Serial Monitor
Serial.println(SlaveReceived);
delay(500);
lcd.clear();
}

1
2
3
4
5
6
7
8
9
10
11
12

voidloop(void)

{

lcd.setCursor(,);//Sets Currsor at line one of LCD

lcd.print(«>>  Slave  <<«);//Prints >> Slave << at LCD

lcd.setCursor(,1);//Sets Cursor at line two of LCD

lcd.print(«MasterVal:»);//Prints MasterVal: in LCD

lcd.print(SlaveReceived);//Prints SlaveReceived value in LCD received from Master

Serial.println(«Slave Received From Master:»);//Prints in Serial Monitor

Serial.println(SlaveReceived);

delay(500);

lcd.clear();

}

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

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

How to use Arduino Serial Read in Proteus?

  • So, now let’s design a small Proteus simulation in which we will see how to use Arduino Serial Read.
  • Proteus doesn’t have Arduino boards in it, so you need to first download this Arduino Library for Proteus and then you will be able to simulate your Arduino board in Proteus.
  • So, design a simple circuit as shown in the below figure:
  • In the above figure, I have placed an LCD and I will get the data from the serial port and then I will print that data on LCD.
  • So, in simple words, whatever I type in the Virtual terminal will be shown on LCD.
  • You also need to download this New LCD Library for Proteus to get this amazing LCD in Proteus.
  • So, now use the below code and Get your Hex File from Arduino Software:
#include <LiquidCrystal.h>

// initialize the library with the numbers of the interface pins
LiquidCrystal lcd(13, 12, 11, 10, 9, 8);

void setup() {
  // set up the LCD's number of columns and rows:
  lcd.begin(20, 4);
  // Print a message to the LCD.
  lcd.setCursor(1,0);
  lcd.print("www.TheEngineering");
  lcd.setCursor(4,1);
  lcd.print("Projects.com");
  lcd.setCursor(1,0);
  Serial.begin(9600);
}

void loop() {
  if(Serial.available()) // Chek for availablity of data at Serial Port
  {
    char data = Serial.read(); // Reading Serial Data and saving in data variable
    Serial.print(data);
    lcd.print(data); // Printing the Serial data
  }
}

Now when you start the Proteus simulation the first screen will look something like this:

Now whatever you write in your Serial Port, will show on the LCD as shown in below figure:

  • That’s how the Arduino Serial Read works.
  • You can download this Proteus simulation and the Arduino code by clicking the Download button given at the start of this post.

So, that’s how you can use the Arduino Serial Read command and can do your task. If it’s still difficult for you then let me know on comments and I will try my best to resolve your issues. Thanks.

See Also

  • Language : Arduino — Serial

  • Language : Serial.available()

  • Language : Serial.availableForWrite()

  • Language : Serial.begin()

  • Language : Serial.end()

  • Language : Serial.find()

  • Language : Serial.findUntil()

  • Language : Serial.flush()

  • Language : Serial.getTimeout()

  • Language : if(Serial)

  • Language : Serial.parseFloat()

  • Language : Serial.parseInt()

  • Language : Serial.peek()

  • Language : Serial.println()

  • Language : Serial.read()

  • Language : Serial.readBytes()

  • Language : Serial.readBytesUntil()

  • Language : Serial.readString()

  • Language : Serial.readStringUntil()

  • Language : serialEvent()

  • Language : Serial.setTimeout()

  • Language : Serial.write()

Что такое протокол I2C и как он работает

Термин IIC расшифровывается как “Inter Integrated Circuits” и часто обозначается как I2C или даже как TWI (2-wire interface protocol), но во всех случаях за этими обозначениями скрывается один и тот же протокол. I2C представляет собой протокол синхронной связи – это значит что оба устройства, которые обмениваются информацией с помощью данного протокола должны использовать общий сигнал синхронизации. Поскольку в этом протоколе используются всего 2 линии (провода), то по одной из них должен передаваться сигнал синхронизации, а по другой – полезная информация.

Впервые протокол I2C был предложен фирмой Phillips. Протокол в самом простом случае соединяет с помощью 2-х линий 2 устройства, одно из устройств должно быть ведущим, а другое – ведомым. Связь возможна только между ведущим и ведомым. Преимуществом протокола (интерфейса) I2C является то, что к одному ведущему можно подключить несколько ведомых.

Схема связи с помощью протокола I2C представлена на следующем рисунке.

Назначение линий данного интерфейса:

  • Serial Clock (SCL): по ней передается общий сигнал синхронизации, генерируемый ведущим устройством (master);
  • Serial Data (SDA): по ней осуществляется передача данных между ведущим и ведомым.

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

Уровни напряжений для передаваемых сигналов в интерфейсе I2C жестко не определены. В этом плане I2C является достаточно гибким, то есть если устройство запитывается от напряжения 5v, оно для связи с помощью протокола I2C может использовать уровень 5v, а если устройство запитывается от напряжения 3.3v, то оно для связи с помощью протокола I2C может использовать уровень 3v. Но что делать если с помощью данного протокола необходимо связать между собой устройства, работающие от различных питающих напряжений? В этом случае используются преобразователи/переключатели напряжения (voltage shifters).

Существует несколько условий для осуществления передачи данных в протоколе I2C. Инициализация передачи начинается с падения уровня на линии SDA, которое определяется как условие для начала передачи (‘START’ condition) на представленной ниже диаграмме. Как видно из этого рисунка, в то время как на линии SDA происходит падение уровня, в это же самое время на линии SCL ведущий поддерживает напряжение высокого уровня (high).

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

Аналогичным образом, повышение уровня на линии SDA останавливает передачу данных, что на представленной диаграмме обозначено как условие окончания передачи данных (‘STOP’ condition). В это же самое время ведущим на линии SCL поддерживается напряжение высокого уровня (high).

На следующем рисунке представлена структура адреса ведомого в протоколе I2C.

Бит R/W показывает направление передачи следующих за ним байт, если он установлен в HIGH – это значит что будет передавать ведомый (slave), а если он установлен в low – это значит что будет передавать ведущий (master).

Каждый бит передается в своем временном цикле, то есть нужно 8 временных циклов чтобы передать байт информации. После каждого переданного или принятого байта 9-й временной цикл используется для подтверждения/не подтверждения (ACK/NACK) приема информации. Этот бит подтверждения (ACK bit) формируется либо ведомым, либо ведущим в зависимости от ситуации. Для подтверждения приема информации (ACK) на линии SDA ведущим или ведомым устанавливается низкий уровень (low) в 9 временном цикле, в противном случае происходит не подтверждение приема информации (NACK).

На следующем рисунке представлена структура передаваемого сообщения в протоколе I2C.

Standard Serial Functions

Serial.begin()

The baud rate input is ignored, and only used for Arduino compatibility.
USB serial communication always occurs at full USB speed. However,
see the baud() function below.

Serial.begin() may wait up to 2.5 seconds for USB serial communication
to be ready. For fastest program startup, simply do not use this
unnecessary function. Its only purpose is for compatibility with
programs written for Arduino. The delay is intended for programs
which do not test the Serial boolean.

  
  
    
    
  
  

Alternately, the wait can be done with a timeout.

        
    
  

Serial.available()

On a standard Arduino, Serial.available() tends to report individual bytes, whereas
large blocks can become instantly available with Teensyduino.
See below for details.

Usually the return value from Serial.available() should be tested as a boolean, either
there is or is not data available. Only the bytes available from the most recently
received USB packet are visible. See
below for details.

Why Would You Want to Use the Serial.print() Function?

You may know that a function is a programming tool – it performs a specific task for you. The Serial.print() function’s task is to send information from your Arduino to your computer, so you can see the value displayed on your computer’s monitor.

There are an endless number of reasons you may want to send information from the Arduino to a computer display, but two reasons really stand out to me:

The first reason is being able to see information that you are generating with your Arduino.

For example, if you have a temperature sensor hooked up to your Arduino and you want to see the value that the temperature sensor is recording, then you can use the Serial.print() function to send the data to a computer monitor via the USB cable. If you open up the serial monitor window (Tools > Serial Monitor), you will see the values streaming in from the Arduino.

The other big reason to send information to a computer display using the Serial.print() function is for developing and debugging Arduino sketches.

Very often, when you are developing an Arduino sketch, what you end up coding does something differently than what you expected it to do. Maybe you have a variable that gets incremented every so often and blinks an LED when it reaches a threshold. When you upload the code to the Arduino, you notice that the LED is blinking more often than it should.

You can look at the code until your eyes bleed, but actually visualizing the variable being incremented , to see its values every time through the loop() can help explain what is happening very quickly.

Проблемы с несколькими аргументами в Serial.print

Проблема при объединении текста и чисел и выводе в print в одной строке

Часто для отладки программы требуется вывести несколько значений, снабдив их каким-то комментарием. Например, такой текст:  «Sensor’s value is:  15». Если вы просто используете такой код:

Serial.print(“Sensor’s value is:  15”);

,то все отобразится правильно. Но если вы попытаетесь вместо подстроки «15» вставить реальное показание датчика, объединив строку и числовое значение, то увидите, что строка выводится некорректно.

Serial.print(“Sensor’s value is:  ” + analogRead (A0));

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

Для решения этой проблемы вы можете использовать два способа:

Первый вариант. Объявить предварительно переменную типа String, инициализировать ее константой-строкой и использовать в аргументе print. Такой вот пример будет работать:

String str = “Sensor’s value is:  “;

Serial.println(str + analogRead(A0));

Второй, более предпочтительный и удобный вариант: использование функции print несколько раз:

Serial.print(“Sensor’s value is:  “);

Serial.println(analogRead(A0));

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

Проблема объединения нескольких строк в аргументе функции print

Попробуйте загрузить скетч с таким фрагментом:

Serial.print(“Sensor’s value is:  ” + analogRead (A0) + “15 cm”);

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

The Basic Use of the Serial.print() Function

Let’s talk about how to use the Serial.print() function.

Say we have a sketch. This sketch has a variable called coolFactor.

I want to be able to monitor the value of the coolFactor variable – that is, I want it displayed on my computer screen. A perfect use for the Serial.print() function!

The first thing we must do in the Arduino sketch is begin serial communications. Like we just said, we use the Serial.begin() function and place it within the setup() of the sketch.

//A variable to hold the level of coolness
int coolFactor = 3;

void setup() {

  Serial.begin(9600);

}

void loop() {

  //Send the value of coolFactor to the the Serial port.
  //So we can see it in the serial monitor window
  Serial.print(coolFactor);

}

Now in the loop(), if I want to display coolFactor’s value with print(), I simply type Serial.print() and in the parenthesis I type the variable name.

If we upload this sketch to the Arduino, the value of coolFactor will be sent to the serial port every time through the loop(). In the Arduino IDE, if you open up the serial monitor window , you will see the values streaming down.

If you enjoyed this lesson, I welcome you to join 1000’s of students who have enjoyed our free Arduino Crash Course – it’s a 19 part video training series on using Arduino (You can sign up below).

Форматирование и конвертация строк

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

Варианты значений констант для форматирования:

  • DEC – обычное число в десятичной системе исчисления
  • BIN – преобразует в двоичный код и выведет строку, содержащую только символы 0 и 1
  • OCT – преобразует в восьмеричную систему исчисления
  • HEX – преобразует в шестнадцатеричную систему
  • Цифра от 0 до 9 – используется, если первый аргумент – вещественное число с плавающей запятой. Форма указывает количество знаков после запятой, которые останутся при выводе. Само число при этом будет округлено.

Примеры:


Serial.println(65, DEC);  // выведет “65”

Serial.println(65, BIN);  // выведет “1000001”

Serial.println(65, OCT);  // выведет 101, т.к. 65 в  8-ной системе исчисления равно 101

Serial.println(65, HEX);  // выведет 41, т.к. 65 в 16-ной системе исчисления равно 41

Serial.println(9.876, 2); // выведет два символа после запятой, предварительно округлив - 9.88

Serial.println(9.876, 0); // выведет число 10

В старых версиях ардуино можно было использовать еще один параметр BYTE. Начиная с версии 1.0 эта константа не поддерживается и компилятор выдаст вам ошибку «Ключевое слово ‘BYTE’ больше не поддерживается». Для вывода ASCII символа по его коду нужно использовать метод write().

Как включить Serial Monitor Arduino

Утилита состоит из окна, разбитого на три части. В верхней части находится поле ввода, где можно с компьютера отправлять данные в последовательный порт. В центре отображаются данные, полученные из последовательного порта. В нижней части окна — меню настроек. Монитор порта Arduino может работать с одним последовательным портом, чтобы не было ошибки при загрузке скетча и открытии Serial Monitor, необходимо выбрать COM порт на котором определилась плата Arduino UNO.

Для открытия утилиты необходимо нажать на иконку в верхнем правом углу Arduino IDE, использовать комбинацию клавиш Ctrl+Shift+M или выбрать в панели меню: Сервис -> Монитор порта. По умолчанию в Serial Monitor для Ардуино установлена скорость передачи данных 9600 бит в секунду, поэтому во многих скетчах используется такая скорость. Если скорость передачи данных в скетче и в настройках монитора порта будут разные, то вся информация будет отображаться в виде иероглифов.