Step 4: Command : Begin()

Description

Sets the data rate in bits per second (baud) for serial data transmission. For communicating with the computer, use one of these rates: 300, 600, 1200, 2400, 4800, 9600, 14400, 19200, 28800, 38400, 57600, or 115200. You can, however, specify other rates — for example, to communicate over pins 0 and 1 with a component that requires a particular baud rate.

An optional second argument configures the data, parity, and stop bits. The default is 8 data bits, no parity, one stop bit.

Syntax

Serial.begin(speed) Serial.begin(speed, config)

Arduino Mega only: Serial1.begin(speed) Serial2.begin(speed) Serial3.begin(speed) Serial1.begin(speed, config) Serial2.begin(speed, config) Serial3.begin(speed, config)

Parameters

speed: in bits per second (baud) — long config: sets data, parity, and stop bits. Valid values are :

SERIAL_5N1

SERIAL_6N1

SERIAL_7N1

SERIAL_8N1 (the default)

SERIAL_5N2

SERIAL_6N2

SERIAL_7N2

SERIAL_8N2

SERIAL_5E1

SERIAL_6E1

SERIAL_7E1

SERIAL_8E1

SERIAL_5E2

SERIAL_6E2

SERIAL_7E2

SERIAL_8E2

SERIAL_5O1

SERIAL_6O1

SERIAL_7O1

SERIAL_8O1

SERIAL_5O2

SERIAL_6O2

SERIAL_7O2

SERIAL_8O2

Example:

void setup() {

Serial.begin(9600); // opens serial port, sets data rate to 9600 bps

}

void loop() {}

Analog In, Out Serial

This example shows you how to read an analog input pin, map the result to a range from 0 to 255, use that result to set the pulse width modulation (PWM) of an output pin to dim or brighten an LED and print the values on the serial monitor of the Arduino Software (IDE).

Circuit

Connect one pin from your pot to 5V, the center pin to analog pin 0 and the remaining pin to ground. Next, connect a 220 ohm current limiting resistor to digital pin 9, with an LED in series. The long, positive leg (the anode) of the LED should be connected to the output from the resistor, with the shorter, negative leg (the cathode) connected to ground.

Code

In the sketch below, after declaring two pin assignments (analog 0 for our potentiometer and digital 9 for your LED) and two variables, and , the only things that you do in the function is to begin serial communication.

Next, in the main loop, is assigned to store the raw analog value read from the potentiometer. Arduino has an range from 0 to 1023, and an range only from 0 to 255, therefore the data from the potentiometer needs to be converted to fit into the smaller range before using it to dim the LED.

In order to convert this value, use a function called map():

is assigned to equal the scaled value from the potentiometer. accepts five arguments: The value to be mapped, the low range and high values of the input data, and the low and high values for that data to be remapped to. In this case, the sensor data is mapped down from its original range of 0 to 1023 to 0 to 255.

The newly mapped sensor data is then output to the dimming or brightening the LED as the potentiometer is turned. Finally, both the raw and scaled sensor values are sent to the Arduino Software (IDE) serial monitor window, in a steady stream of data.

/*
  Analog input, analog output, serial output
  Reads an analog input pin, maps the result to a range from 0 to 255 and uses
  the result to set the pulse width modulation (PWM) of an output pin.
  Also prints the results to the Serial Monitor.
  The circuit:
  — potentiometer connected to analog pin 0.
    Center pin of the potentiometer goes to the analog pin.
    side pins of the potentiometer go to +5V and ground
  — LED connected from digital pin 9 to ground
  created 29 Dec. 2008
  modified 9 Apr 2012
  by Tom Igoe
  This example code is in the public domain.
  http://www.arduino.cc/en/Tutorial/AnalogInOutSerial
*/// These constants won’t change. They’re used to give names to the pins used:
const int analogInPin = A0;  // Analog input pin that the potentiometer is attached to
const int analogOutPin = 9; // Analog output pin that the LED is attached toint sensorValue = ;        // value read from the potint outputValue = ;        // value output to the PWM (analog out)void setup() {
  // initialize serial communications at 9600 bps:
  Serial.begin(9600);}void loop() {
  // read the analog in value:
  sensorValue = analogRead(analogInPin);
  // map it to the range of the analog out:
  outputValue = map(sensorValue, , 1023, , 255);
  // change the analog out value:
  analogWrite(analogOutPin, outputValue);
  // print the results to the Serial Monitor:
  Serial.print(«sensor = «);
  Serial.print(sensorValue);
  Serial.print(«\t output = «);
  Serial.println(outputValue);
  // wait 2 milliseconds before the next loop for the analog-to-digital
  // converter to settle after the last reading:
  delay(2);}

See Also:

• map()
• analogRead()
• analogWrite()

• serial()

• AnalogInput — Use a potentiometer to control the blinking of an LED.
• AnalogWriteMega — Fade 12 LEDs on and off, one by one, using an Arduino or Genuino Mega board.
• Calibration — Define a maximum and minimum for expected analog sensor values.
• Fading — Use an analog output (PWM pin) to fade an LED.
• Smoothing — Smooth multiple readings of an analog input.

Last revision 2015/07/28 by SM

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

}

Объект Serial

Начнём знакомство с одной из самых полезных штук Arduino-разработчика – Serial. Serial это объект класса Stream, позволяющий как просто принимать/отправлять данные через последовательный порт, так и наследует из класса Stream кучу интересных возможностей и фишек, давайте сразу их все рассмотрим, а потом перейдём к конкретным примерам.

Запустить связь по Serial на скорости speed (baud rate, бит в секунду). Скорость можно поставить любую, но есть несколько “стандартных”. Список скоростей для монитора порта Arduino IDE:

• 300
• 1200
• 2400
• 4800
• 9600 чаще всего используется, можно назвать стандартной для большинства устройств с связью через TTL
• 19200
• 38400
• 57600
• 115200 тоже часто встречается
• 230400
• 250000
• 500000
• 1000000
• 2000000

Отправляет в порт значение val – число или строку. В отличие от write выводит именно символы, т.е. отправив 88 вы получите 88: Serial.print(88); выведет 88. Также метод print/println имеет несколько настроек для разных данных, что делает его очень удобным инструментом отладки:

format позволяет настраивать вывод данных: BIN, OCT, DEC, HEX выведут число в соответствующей системе исчисления, а цифра после вывода float позволяет настраивать выводимое количество знаков после точки

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

Читает данные из буфера и ищет набор символов target (тип char), опционально можно указать длину length. Возвращает true, если находит указанные символы. Ожидает передачу по таймауту

Отправка и парсинг

Рассмотрим самый классический пример для всех языков программирования: Hello World!

Отправка данных в порт не должна вызывать трудностей и вопросов, потому что всё понятно/очевидно, да и чуть выше в описании метода print мы рассмотрели все варианты вывода. Отправка в порт позволяет узнать значение переменной в нужном месте программы, этот процесс называется отладка. Когда код работает не так, как нужно, начинаем смотреть, где какие переменные какие значения принимают. Или выводим текст из разных мест программы, чтобы наблюдать за правильностью (порядком) её работы. Давайте вспомним урок циклы и массивы и выведем в порт массив:

Вывод: 0 50 68 85 15 214 63 254 – элементы массива, разделённые пробелами!

Проблемы возникают при попытке принять данные в порт. Дело в том, что метод read() читает один символ, даже если вы отправите длинное число – программа получит его по одной цифре, и составлять число из цифр придётся вручную. Проблема усугубляется тем, что read() читает именно символ, то есть код символа в таблице ASCII.

Посмотрим вот такой пример, в котором в порт отправляются принятые в него данные (так называемое эхо):

Так как же принять именно цифру? Есть хитрость – вычитать из полученного кода символа код цифры 0, либо сам 0 в виде символа: ‘0’

Также для принятия одиночных чисел у нас есть готовый метод – parseInt/parseFloat – для целочисленных и рациональных чисел соответственно. Процесс приёма и расшифровки данных называется парсинг (parsing). Давайте примем в порт число 1234, используя готовый метод парсинга.

Итак, мы используем конструкцию if (Serial.available()) <> чтобы опрашивать порт только в том случае, если в него что-то пришло. Отправив в порт число 1234 мы получим ответ ОК, отправив любое другое – error. Также вы заметите, что после отправки проходит секунда, прежде чем плата ответит. Эта секунда спрятана внутри метода parseInt, программа ждёт секунду после принятия данных, чтобы все данные успели прийти. Секунда это очень много, достаточно было ждать, скажем, 50 миллисекунд. Это можно сделать при помощи метода setTimeout.

Теперь после отправки цифры программа будет ждать всего 50 мс, и сразу же вам ответит.

В реальном устройстве часто требуется передавать несколько параметров, например у нас Bluetooth танк. Мы ему должны отправить например скорость правой гусеницы, скорость левой гусеницы, положение башни, состояние подсветки, команду на выстрел… Да что угодно. Как быть в таком случае? Тут начинается настоящий парсинг, и появляются варианты, нам придётся придумывать собственный протокол связи.

Есть два базовых варианта: отправка пакета всех-всех данных и его парсинг, или отправка отдельно каждого параметра с уникальным “ключом” у каждого. Как это понимать: суть первого варианта состоит в принятии пакета данных, которые разделены разделителем. Также правильно будет выделить начало и конец посылки. Пример: $120 80 180 1; – начальный символ $, разделитель ” ” (пробел) и завершающий символ ; . Наличие начального и завершающего символа повышает скорость работы и помехозащищённость связи. Второй вариант – посылки вида MOT1_120, содержащие ключ и значение, соответствующее этому ключу.

Как реализовать данные способы парсинга я очень подробно разбирал в примерах в сборнике полезных алгоритмов Arduino, раздел “Работа с Serial”. Но давайте я оставлю их также и здесь, пользуйтесь!

Монитор последовательного порта Ардуино ► встроен в среду Arduino IDE и служит для связи компьютера с контроллером. Рассмотрим, команды для работы с утилитой.

Монитор порта Ардуино – это утилита, встроенная в среду программирования Arduino IDE и служит она для связи компьютера с контроллером. С помощью монитора последовательного порта производится отладка прошивки микроконтроллера, получение информации о работе программы и отправка команд к микроконтроллеру по USB. Рассмотрим, как работать с утилитой: выбор скорости обмена информацией, команды в скетче для вывода текста и переменных на Serial Monitor Arduino IDE.

Управление через Serial на Arduino

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

// контакты для светодиодов:
const int redPin = 5;
const int greenPin = 4;
const int bluePin = 3;

void setup() {
  // инициализировать последовательную связь:
  Serial.begin(9600);
  // сделать пины выводами:
  pinMode(redPin, OUTPUT);
  pinMode(greenPin, OUTPUT);
  pinMode(bluePin, OUTPUT);

}

void loop() {
  // если есть последовательная связь, прочитать:
  while (Serial.available() > 0) {

    // искать действительное целое число:
    int red = Serial.parseInt();
    // сделать это снова:
    int green = Serial.parseInt();
    // сделать это снова:
    int blue = Serial.parseInt();

    // искать новую строку, окончание выражения:
    if (Serial.read() == '\n') {
      // ограничить значения 0-255 и инвертировать:
      // если светодиод с общим катодом, то использовать "constrain(color, 0, 255);"
      red = 255 - constrain(red, 0, 255);
      green = 255 - constrain(green, 0, 255);
      blue = 255 - constrain(blue, 0, 255);

      // постепенное угасание красного, зеленого и синего:
      analogWrite(redPin, red);
      analogWrite(greenPin, green);
      analogWrite(bluePin, blue);

      // вывести три числа в одну строку в шестнадцатеричном виде:
      Serial.print(red, HEX);
      Serial.print(green, HEX);
      Serial.println(blue, HEX);
    }
  }
}

После загрузки и запуска кода откройте Serial Monitor в Arduino IDE (Инструменты -> Serial Monitor). Выберите 9600 бод (скорость, что мы использовали в коде) и выберите «Newline» (Новая строка) в поле выбора окончания строки (это поле слева от выбора скорости)

Это важно, потому что по умолчанию не происходит отправки перевода строки и нам нужно определить окончание строки

Теперь наберите 255,0,0 и нажмите ввод, чтобы увидеть, как светодиод становится красным.

Проблемы с несколькими аргументами в 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”);

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

print()

Описание

Функция выводит через последовательный порт заданный ASCII-текст в виде, понятном для человека. Эта команда может иметь несколько разных форм. При выводе числа каждой его цифре соответствует один ASCII-символ. Дробные числа тоже выводятся в виде ASCII-цифр, при этом после запятой по умолчанию оставляется два десятичных знака. Байты выводятся в виде отдельных символов, а символы и строки выводятся без изменений — «как есть». Например:

• Serial.print(78) — выведет «78»
• Serial.print(1.23456) — выведет «1.23»
• Serial.print(‘N’) — выведет «N»
• Serial.print(«Hello world.») — выведет «Hello world.»

Необязательный второй параметр задает формат вывода; этот параметр может принимать следующие значения: BIN (двоичная система с основанием 2), OCT (восьмеричная система с основанием 8), DEC (десятичная система с основанием 10), HEX (шестнадатиричная система с основанием 16). Для числе с плавающей точкой этот параметр определяет количество десятичных знаков после запятой. Например:

• 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.println(1.23456, 4) — выведет «1.2346»

Функции Serial.print() можно передавать и строки, записанные во флеш-память контроллера. Для этого их нужно заключить в конструкцию F(). Например:

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

Для отправки отдельного байта используйте функцию Serial.write().

Параметры

val: значение, которое необходимо вывести — любой тип данных

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

Пример

/*
Использования цикла FOR для обработки данных и вывода чисел в различных форматах.
*/
int x = 0;    // переменная

void setup() {
  Serial.begin(9600);      // открываем последовательный порт на скорости 9600 бод    
}

void loop() {  
  // print labels 
  Serial.print("NO FORMAT");       // выводим метку
  Serial.print("\t");              // выводим символ табуляции

  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++){    // немного ASCII-графики, можете изменить код по своему вкусу

    // выводим значение в различных форматах:
    Serial.print(x);       // выводим как десятичное число - то же, что и формат "DEC"
    Serial.print("\t");    // выводим символ табуляции

    Serial.print(x, DEC);  // выводим десятичное число ASCII-символами
    Serial.print("\t");    // выводим символ табуляции

    Serial.print(x, HEX);  // выводим шестнадатиричное число ASCII-символами
    Serial.print("\t");    // выводим символ табуляции

    Serial.print(x, OCT);  // выводим восьмиричное число ASCII-символами
    Serial.print("\t");    // выводим символ табуляции

    Serial.println(x, BIN);  // выводим двоичное число ASCII-символами
    //с символом возврата каретки, который добавляет функция "println"
    delay(200);            // задержка в 200 миллисекунд
  }
  Serial.println("");      // выводим еще один символ возврата каретки
}

Совет

Во всех версиях Ардуино, начиная с версии 1.0, последовательная передача данных осуществляется асинхронно, вследствие чего функция Serial.print() завершается до самой отправки данных.

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

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

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

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

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

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

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

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

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

Introduction: Arduino Serial

By Adarsh CFollow

More by the author:

About: Im a tech enthusiast

More About Adarsh C »

Serial communication on pins TX/RX uses TTL logic levels (5V or 3.3V depending on the board). Don’t connect these pins directly to an RS232 serial port; they operate at +/- 12V and can damage your Arduino board.

Serial is used for communication between the Arduino board and a computer or other devices. All Arduino boards have at least one serial port (also known as a UART or USART): Serial. It communicates on digital pins 0 (RX) and 1 (TX) as well as with the computer via USB. Thus, if you use these functions, you cannot also use pins 0 and 1 for digital input or output.

You can use the Arduino environment’s built-in serial monitor to communicate with an Arduino board. Click the serial monitor button in the toolbar and select the same baud rate used in the call to begin().

The Arduino Mega has three additional serial ports: Serial1 on pins 19 (RX) and 18 (TX), Serial2 on pins 17 (RX) and 16 (TX), Serial3 on pins 15 (RX) and 14 (TX). To use these pins to communicate with your personal computer, you will need an additional USB-to-serial adaptor, as they are not connected to the Mega’s USB-to-serial adaptor. To use them to communicate with an external TTL serial device, connect the TX pin to your device’s RX pin, the RX to your device’s TX pin, and the ground of your Mega to your device’s ground.

Управление светодиодом через последовательный порт с помощью PHP

Теперь, когда последовательная связь настроена, нам нужно написать небольшой PHP-скрипт для отправки команд через последовательный порт на плату Arduino. Для этого мы будем использовать библиотеку Composer hyperthese/php-serial.

Создайте файл , куда напишем такую программу:

<?php

require __DIR__ . '/vendor/autoload.php';

$serial = new PhpSerial();

// порт Arduino:
$serial->deviceSet("/dev/ttyACM0");
$serial->confBaudRate(9600);
$serial->confParity("none");
$serial->confCharacterLength(8);
$serial->confStopBits(1);
$serial->confFlowControl("none");

$serial->deviceOpen();

// отсылаем цвета в виде строк CSV
$colors   = '255, 0, 0';
$colors = '0, 255, 0';
$colors  = '0, 0, 255';

foreach ($colors as $color => $value) {
        echo "Отправляем $color\n";
        $serial->sendMessage($value . "\n");
        sleep(1);
}

echo "Сделано\n";

Обратите внимание, что очень важно использовать одинаковую скорость передачи везде. Здесь мы используем 9600

Далее выполняем:

php led.php

Ниже небольшая демонстрация управления платой Ардуино с использованием PHP, API Twitter и старого LOLShield.

Конечно, это уже сложнее, но наш урок является отправной точкой для дальнейшей реализации такого проекта. Отдельное спасибо за проект Эрике Хайди (heidislab.com).

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.

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

Step 2: Command : Available()

Description

Get the number of bytes (characters) available for reading from the serial port. This is data that’s already arrived and stored in the serial receive buffer (which holds 64 bytes). available() inherits from the Stream utility class.

Syntax

Serial.available()

Arduino Mega only: Serial1.available() Serial2.available() Serial3.available()

Parameters

none

Returns

the number of bytes available to read

Example

int incomingByte = 0; // for incoming serial data

void setup() {

Serial.begin(9600); // opens serial port, sets data rate to 9600 bps

}

void loop() {

// send data only when you receive data:

if (Serial.available() > 0) {

// read the incoming byte:

incomingByte = Serial.read();

// say what you got:

Serial.print(«I received: «);

Serial.println(incomingByte, DEC);

}

}