Чтение данных из последовательного порта. урок 6. ардуино

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

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

Пример работы с кнопкой

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

Пример скетча отслеживания нажатия кнопки

#define PIN_INPUT 2
#define PIN_LED 13

void setup() {
 Serial.begin(9600); 
 pinMode(PIN_INPUT, INPUT);
 pinMode(PIN_LED, OUTPUT);
}

void loop() {
 int sensorVal = digitalRead(PIN_INPUT);
 Serial.println(sensorVal); // Выводим значение в мониторе порта

// Нужно иметь в виду, что логика работы кнопки такова
 // - Если кнопка не нажата, то на вход поступает высокий уровень сигнала
 // - Если мы нажали кнопку, то на входе будет логический ноль
 if (sensorVal == HIGH) {
 digitalWrite(PIN_LED, LOW); // Кнопка не нажата - выключаем светодиод
 } else {
 digitalWrite(PIN_LED, HIGH);// А теперь кнопка нажата - светодиод включается
 }
}

Схема подключения максимально проста:

Пример скетча с INPUT_PULLUP

Сам скетч меняется минимально. Мы просто определяем тип пина как INPUT_PULLUP и получаем в итоге гораздо меньше хаоса на входе:

#define PIN_INPUT_PULLUP 2

void setup() {
  Serial.begin(9600);
  pinMode(PIN_INPUT_PULLUP, INPUT_PULLUP);
}

void loop() {
  int sensorVal = digitalRead(PIN_INPUT_PULLUP);
  Serial.println(sensorVal);
}

Пример подключения датчика движения

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

Arduino Code libraries

Library Structure

A library is a folder comprised of files with C++ (.cpp) code files and C++ (.h) header files.

The .h file describes the structure of the library and declares all its variables and functions.

The .cpp file holds the function implementation.

Importing Libraries

The first thing you need to do is find the library you want to use out of the many libraries available online. After downloading it to your computer, you just need to open Arduino IDE and click on Sketch > Include Library > Manage Libraries. You can then select the library that you want to import into the IDE. Once the process is complete the library will be available in the sketch menu.

In the code provided by circuito.io instead of adding external libraries like mentioned before, we provide them with the firmware folder. In this case, the IDE knows how to find them when using #include.

From Software to Hardware

There is a lot to be said of Arduino’s software capabilities, but it’s important to remember that the platform is comprised of both software and hardware. The two work in tandem to run a complex operating system.

Code →  Compile → Upload →  Run

At the core of Arduino, is the ability to compile and run the code.

After writing the code in the IDE you need to upload it to the Arduino. Clicking the Upload button (the right-facing arrow icon), will compile the code and upload it if it passed compilation. Once your upload is complete, the program will start running automatically.

You can also do this step by step:

1. First, compile the code. To do this simply click the check icon (or click on sketch > Verify / Compile in the menu bar.

As you can see, the check icon is located in the top left underneath the “File” tag in the menu section.

Once you’ve done this, Arduino will start to compile. Once it’s finished, you’ll receive a completion message that looks like this:

As you can see, the green line at the bottom of the page tells you that you’re “done compiling”. If your code fails to run, you’ll be notified in the same section, and the problematic code will be highlighted for editing.

Once you’ve compiled your sketch, it’s time to upload it.

1. Choose the serial port your Arduino is currently connected to. To do this click on Tools > Serial port in the menu to designate your chosen serial port (as shown earlier above). You can then upload the compiled sketch.
2. To upload the sketch, click on the upload icon next to the tick. Alternatively you can go the the menu and click File> upload. Your Arduino LEDS will flicker once the data is being transferred.

Once complete, you’ll be greeted with a completion message that tells you Arduino has finished uploading.

Setting Up Your IDE

In order to connect an Arduino board to your computer you need a USB cable. When using the Arduino UNO, the USB transfers the data in the program directly to your board. The USB cable is used to power your arduino. You can also run your Arduino through an external power source.

Before you can upload the code, there are some settings that you need to configure.

Choose your board — You need to designate which Arduino board you’re going to be using. Do this by click Tools > Board > Your Board.

Choose your processor- there are certain boards (for example Arduino pro-mini) for which you need to specify which processor model you have. Under tools > processor > select the model you have.

Choose your port — to select the port to which your board is connected, go to tools > Port > COMX Arduino (This is Arduino’s serial port).

How to Install Non-Native Boards (e.g. NodeMCU)

Some board models are not pre-installed in the Arduino IDE, therefore you’ll need to install them before you can upload code.

 To install a non-native board such as NodeMCU, you need to:

1. Click on tools > Boards > Boards Manager
2. Search for the board you want to add in the search bar and click “install”.

Some boards cannot be found through the Board Manager. In this case, you’ll need to add them manually. In order to do this:

1. Click on Files > Preferences
2. In the Additional Boards Manager field, paste the URL of the installation package of your board. For instance, for nodeMCU, add the following URL: http://arduino.esp8266.com/stable/package_esp8266com_index.json
3. Click OK
4. Go to tools > Boards > Boards Manager
5. Search for the board you want to add in the search bar and click “install”.

Once you’ve completed this step, you will see the installed boards in the boards’ list under tools.

Note: the process may differ slightly for different boards.

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

Для этого занятия нам потребуется:

плата Arduino Uno / Arduino Nano / Arduino Mega.

Как включить монитор порта ардуино: команды, скетч

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

Пример 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.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 начнет циклично отправлять количество символов, доступных в буфере последовательного порта.

How to program Arduino

The basic Arduino code logic is an  “if-then” structure and can be divided into 4 blocks:

Setup — will usually be written in the setup section of the Arduino code, and performs things that need to be done only once, such as sensor calibration.

Input — at the beginning of the loop, read the inputs. These values will be used as conditions (“if”) such as the ambient light reading from an LDR using analogRead().

Manipulate Data — this section is used to transform the data into a more convenient form or perform calculations. For instance, the AnalogRead() gives a reading of 0-1023 which can be mapped to a range of 0-255 to be used for PWM.(see analogWrite())

Output —  this section defines the final outcome of the logic (“then”) according to the data calculated in the previous step. Looking at our example of the LDR and PWM, turn on an LED only when the ambient light level goes below a certain threshold.

Задания

1. Соберите схему с Arduino и двумя кнопками, подключенными к пинам 5 и 6 с помощью резисторов номиналом 10 кОм. Запрограммируйте Arduino чтобы при нажатии первой кнопки в монитор порта выводилась фраза «Button 1», а при нажатии второй кнопки «Button 2».

2. Соберите схему с Arduino и двумя светодиодами, подключенными к пинам 8 и 12 с помощью резисторов 390 Ом. Запрограммируйте Arduino чтобы при считывании из монитора порта значения «1» включался первый светодиод, а при считывании значения «2» он выключался. И, аналогично, при считывании из порта значения «3» должен включаться второй светодиод, а при считывании значения «4» он должен выключаться.

Работа с EEPROM

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

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

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

Существует несколько ситуаций, когда память EEPROM содержит неправильные данные:

1. При первоначальной активации – еще не было ни одной записи.
2. В момент неконтролируемого отключения питания – часть или все данные не запишутся или запишутся некорректно.
3. После завершения возможных циклов перезаписи данных.

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

Для контроля целостности информации используют контрольный код системы. Он создается по образцу записи первоначальных данных и, при проверке, он вновь просчитывает данные. Если результат отличается – это ошибка. Самым распространенным вариантом такой проверки является контрольная сумма – выполняется обычная математическая операция по сложению всех значений ячеек.

Опытные программисты добавляют к этому коду дополнительное «исключающее ИЛИ», например, E5h. В случае если все значения равны нулю, а система по ошибке обнулила исходные данные – такая хитрость выявит ошибку.

Таковы основные принципы работы с энергонезависимой памятью EEPROM для микроконтроллеров Arduino. Для определенных проектов стоит использовать только этот вид памяти. Он имеет как свои плюсы, так и свои недостатки. Для освоения методов записи и чтения лучше начать с простых задач.

Other considerations

• Serial comms is not self-clocked (unlike SPI or I2C, and others) hence both sender and receiver have to agree on a clock rate.

• The clock rate is not exact on the Arduino, because the hardware has to divide the system clock down to get a serial clock, and the division is not always exact. There is almost always an error, the amount is given in the datasheet (figures quoted for a 16 MHz system clock, such as on the Uno):

• You can vary the number of data bits, you don’t have to send 8 of them, in fact you can send 5 to 9 bits.

• There can optionally be a parity bit sent after the data bits.

  • If you specify «odd» parity, the parity bit is set in such a way that the total number of 1-bits is odd.
  • If you specify «even» parity, the parity bit is set in such a way that the total number of 1-bits is even.
  • If you specify no parity, the parity bit is omitted.

  This can help the receiver detect if the data arrived correctly or not.

• The parity bit is sent before the stop bit.

• In the case of 9 data bits (as used in the SeaTalk protocol) the parity bit is re-purposed as a 9th data bit. Therefore you can’t have both 9 data bits and a parity bit.

• You can also have two stop bits. This basically just lengthens the time between bytes. In the «olden days» this was so that slow electromechanical equipment could process the previous byte (eg. to print it).

Possible corruption

If you start listening to serial data in the middle of a stream, it is quite possible that a 0-bit in the middle of the stream will be interpreted as a start bit, and then the receiver will interpret everything after that incorrectly.

The only real way to recover from this is to have a large enough gap, from time to time, (eg. 10 bits long) that this cannot happen.

Inverted logic

The bits shown here (logic-level) are not inverted. That is, a 1-bit is HIGH and a 0-bit is LOW. If you have RS232 equipment that will probably be sending something like -12 V for a 1-bit, and +12 V for a 0-bit. This is inverted because a one is less than a zero, voltage-wise.

If you have such devices you need to do voltage conversion and logic inversion. Chips like the MAX232 will do both for you. They can also provide the -12 V needed to drive such equipment by generating it internally with the help of a few user-supplied capacitors.

Speed rule-of-thumb

Since, with one start bit, 8 data bits, and one stop bit we have a total of 10 bits, as a quick rule of thumb, you can calculate the number of bytes you can transmit in a second by dividing the bit rate by 10.

Eg. At 9600 BPS you can send 960 bytes per second.

Code to reproduce:

Программирование платы Arduino с помощью технологии Bluetooth

Для беспроводного программирования платы Arduino первым делом мы должны написать программу чтобы плата Arduino отвечала на AT команды. Для этого подключите плату Arduino к компьютеру с помощью USB кабеля и загрузите в нее следующий код программы:

Arduino

#include <SoftwareSerial.h>
SoftwareSerial HC05(2,3);
void setup()
{
Serial.begin(9600);
Serial.println(«Enter AT commands:»);
HC05.begin(38400);
}
void loop()
{
if (HC05.available())
Serial.write(HC05.read());
if (Serial.available())
HC05.write(Serial.read());
}

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

Arduino

#include <SoftwareSerial.h>
SoftwareSerial HC05(2,3);

Далее в функции setup мы установим скорость последовательной передачи данных для аппаратного и программного созданного (с помощью библиотеки SoftwareSerial) последовательных портов – 9600 и 38400 бод соответственно.

Arduino

void setup()
{
Serial.begin(9600);
Serial.println(«Enter AT commands:»);
HC05.begin(38400);
}

Затем в функции loop мы будем использовать два условия (с помощью оператора if). В первом условии мы будем проверять поступает ли какая либо информация от модуля HC05 – если да, то мы будем передавать ее по аппаратному последовательному порту платы Arduino. Во втором условии мы будем проверять поступают ли какие либо команды из окна монитора последовательной связи (Arduino Serial Monitor) – если да, то мы будем передавать их модулю HC05.

Arduino

void loop()
{
if (HC05.available())
Serial.write(HC05.read());
if (Serial.available())
HC05.write(Serial.read());
}

Далее подключим модуль HC05 к плате Arduino чтобы она работала в режима приема (и исполнения) AT команд. Схема этого подключения представлена на следующем рисунке:

Перед подключением платы Arduino к компьютеру нажмите key button на Bluetooth модуле и затем подключайте плату к компьютеру. Держите key button в нажатом состоянии до тех пор пока светодиод на Bluetooth модуле не начнет мигать с интервалом 2 секунды. В режиме команд (command mode) светодиод Bluetooth модуля мигает медленнее чем в обычном режиме функционирования.

Теперь откройте монитор последовательного порта и вводите в нем следующие представленные команды. В ответ на эти команды плата должна отвечать сообщением «OK» если команда была выполнена успешно.

Если все представленные AT команды успешно протестированы, разберите схему и соберите новую схему, представленную на следующем рисунке:

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

Используйте адаптер питания или батарейку 9V чтобы подать питание на плату Arduino. После этого зайдите в «устройства» (‘Devices’) вашего компьютера (ноутбука) и включите Bluetooth, после чего соединитесь по Bluetooth с модулем HC05.

После того, как Bluetooth соединение между устройствами будет установлено, необходимо определить COM порт компьютера/ноутбука, к которому подключился Bluetooth модуль HC05. Для этого зайдите в диспетчер устройств (‘Device Manager’) и проверьте в нем устройства, которые подключены по COM портам. Там должно показываться два порта: один для входящей и один для исходящей связи. Нам будет необходим номер второго из этих COM портов поскольку мы собираемся передавать код программы в плату Arduino.

Теперь откройте Arduino IDE и в ней выберите пример программы с миганием светодиода, затем выберите необходимый COM порт и нажмите кнопку загрузки программы (upload button). Если все прошло хорошо, то встроенный в плату Arduino светодиод начнет мигать с интервалом в 1 секунду.

Исходный код программы (скетча)

Arduino

#include <SoftwareSerial.h>
SoftwareSerial HC05(2,3);
void setup()
{
Serial.begin(9600);
Serial.println(«Enter AT commands:»);
HC05.begin(38400);
}
void loop()
{
if (HC05.available())
Serial.write(HC05.read());
if (Serial.available())
HC05.write(Serial.read());
}

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. удалив из кода строчки для записи данных, вы можете каждый раз при запуске программы считывать все сохраненные данные из ПЗУ Ардуино.

Arduino Coding Environment and basic tools

What language is Arduino?

Arduino code is written in C++ with an addition of special methods and functions, which we’ll mention later on. C++ is a human-readable programming language. When you create a ‘sketch’ (the name given to Arduino code files), it is processed and compiled to machine language.

Arduino IDE

The Arduino Integrated Development Environment (IDE) is the main text editing program used for Arduino programming. It is where you’ll be typing up your code before uploading it to the board you want to program. Arduino code is referred to as sketches.

Note: It’s important to use the latest version of Arduino IDE. From time to time, check for updates here.

Arduino code example

As you can see, the IDE has a minimalist design. There are only 5 headings on the menu bar, as well as a series of buttons underneath which allow you to verify and upload your sketches. Essentially, the IDE translates and compiles your sketches into code that Arduino can understand. Once your Arduino code is compiled it’s then uploaded to the board’s memory.

All the user has to do to start compiling their sketch is press a button (a guide to this can be found below).

If there are any errors in the Arduino code a warning message will flag up prompting the user to make changes. Most new users often experience difficulty with compiling because of Arduino’s stringent syntax requirements. If you make any mistakes in your punctuation when using Arduino, the code won’t compile and you’ll be met with an error message.

Serial Monitor and Serial Plotter 

Arduino serial monitor can be opened by clicking on the magnifying glass icon on the upper right side of the IDE or under tools. The serial monitor is used mainly for interacting with the Arduino board using the computer, and is a great tool for real-time monitoring and debugging. In order to use the monitor, you’ll need to use the Serial class.

The code you download from circuito.io has a test section that helps you test each components using the serial monitor, as you can see in the screenshot below:

Arduino serial plotter is another component of the Arduino IDE, which allows you to generate a real-time graph of your serial data. The serial plotter makes it much easier for you to analyze your data through a visual display. You’re able to create graphs, negative value graphs, and conduct waveform analysis.

Debugging Arduino Code and Hardware

Unlike other software programming platforms, Arduino doesn’t have an onboard debugger. Users can either use third-party software, or they can utilize the serial monitor to print Arduino’s active processes for monitoring and debugging.

By using the Serial class, you can print to the serial monitor, debugging comments and values of variables. On most Arduino models, this will be using serial pins 0 and 1 which are connected to the USB port.

Синтаксис функции

Команда Serial.begin () состоит из двух частей. Первая часть, Serial, является названием класса библиотеки для работы с монитором порта. Вторая часть, begin() обозначает название метода, которому мы должны передать один аргумент – скорость обмена данными. Функция не возвращает значений.

Синтаксис функции, два варианта:

Serial.begin(<скорость>)

Serial.begin(<скорость>, <config> )

Параметры:

• скорость – скорость взаимодействия (бит/сек или бод).
• config – настройки режима работы последовательного порта. По умолчанию используется наиболее распространенный вариант, SERIAL_8N1.

Скорость для последовательного порта в Serial.begin()

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

Кроме стандартного значения можно устанавливать и другие: 300, 1200, 2400, 4800, 9600, 14400, 19200, 28800, 38400, 57600, 115200. Чем выше цифра, тем выше скорость обмена, но нужно следить, чтобы эту скорость поддерживало и внешнее устройство. В некоторых ситуациях слишком высокая скорость обмена может привести к ошибкам, нужно учитывать и это. Так, например, значение 115200 устанавливаются обычно специальными высокоскоростными устройствами, например, полетными контроллерами. Значения ниже 9600 используются крайне редко.

Второй параметр для последовательного порта

Параметр config в функции begin обычно не указывается, т.к. крайне редко надо менять значения по умолчанию. Но на всякий случай приведем здесь возможные варианты параметров, которые можно найти в HardwareSerial.h:

• #define SERIAL_5N1 0x00
• #define SERIAL_6N1 0x02
• #define SERIAL_7N1 0x04
• #define SERIAL_8N1 0x06
• #define SERIAL_5N2 0x08
• #define SERIAL_6N2 0x0A
• #define SERIAL_7N2 0x0C
• #define SERIAL_8N2 0x0E
• #define SERIAL_5E1 0x20
• #define SERIAL_6E1 0x22
• #define SERIAL_7E1 0x24
• #define SERIAL_8E1 0x26
• #define SERIAL_5E2 0x28
• #define SERIAL_6E2 0x2A
• #define SERIAL_7E2 0x2C
• #define SERIAL_8E2 0x2E
• #define SERIAL_5O1 0x30
• #define SERIAL_6O1 0x32
• #define SERIAL_7O1 0x34
• #define SERIAL_8O1 0x36
• #define SERIAL_5O2 0x38
• #define SERIAL_6O2 0x3A
• #define SERIAL_7O2 0x3C
• #define SERIAL_8O2 0x3E

В этих константах обозначаются разные варианты структуры пакета данных. Например, SERIAL_8N2 означает, что по последовательному порту ардуино передаст пакет длиной 8 бит без бита контроля четности (указано N) и с одним стоповым битом, который будет добавлен после байта данных.

4Запись чисел с плавающей запятой и строк в EEPROM

Для записи чисел с плавающей запятой и строк нужно использовать метод EEPROM.put(), а для чтения – EEPROM.get().

#include <EEPROM.h> // подключаем библиотеку

void setup() {
  int addr = 0; // адрес 
  float f = 3.1415926f; // число с плавающей точкой (типа float)
  EEPROM.put(addr, f); // записали число f по адресу addr
  
  addr += sizeof(float); // вычисляем следующую свободную ячейку памяти
  char name = "Hello, SolTau.ru!"; // создаём массив символов
  EEPROM.put(addr, name); // записываем массив в EEPROM 
  Serial.begin(9600); // инициализация послед. порта
}

void loop() {
  for (int addr=0; addr}

  delay(60000); // ждём 1 минуту
}

В процедуре setup() сначала запишем число с плавающей запятой «f». Затем сдвинемся на количество ячеек памяти, которое занимает тип «float», и запишем строку символов «char» ёмкостью 20 ячеек.

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

Запись чисел с плавающей запятой в EEPROM Arduino

Видно, что значение в ячейках с 0 по 3 правильно определилось как число с плавающей точкой, а начиная с 4-ой – как строка.

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

Функции 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’);

Похожие записи:

Выбор импульсных зарядных устройств для автомобильного аккумулятора Как подключить бра с выключателем шнурком, цепочкой Гофрированная труба для вытяжки и ее преимущества Оптоволоконные линии связи: неограниченные возможности Какой дифавтомат поставить? Рекани анжело люстры