Arduino convert bool to string

Arduino

Типы данных

Тип	Занимаемый размер (байт)	Минимальное значение	Максимальное значение
boolean	1	false	true
char	1	-128	127
byte	1	0	255
int, short	2	-32768	32767
unsigned int	2	0	65535
long	4	-2147483648	2147483647
unsigned long	4	0	4294967295
float, double	4	-3.4028235E+38	3.4028235E+38

boolean

Логический тип, может принимать только 2 значения — true (правда) и false (ложь). В памяти занимает 1 байт.

Тип позволяет хранить 1 алфавитно-цифровой символ и занимае 1 байт. Для записи символа используются одинарные кавычки.

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

Переменная это типа — знаковая, диапазон допустимых значений — от -128 до 127.

Тип для хранения однобайтового целого беззнакового числа. Соответственно диапазон значений от 0 до 255.

Пожалуй самый частоиспользуемый тип для хранения целых чисел со знаком — integer (целое число). Занимает 2 байта и может хранить цисла от -32768 до 32767.

На платформе Arduino также присутствует тип , который ничем не отличается от типа int .

unsigned int

Беззнаковое целое число, занимает так же, как и int , 2 байта. Диапазон значений — от 0 до 65535.

Тип long служит для хранение больших целых знаковых чисел. Диапазон его значений от -2147483648 до 2147483647, а занимает в памяти он 4 байта.

unsigned long

Беззнаковое целое число расширенного диапазона может хранить значения от 0 до 4294967295 и занимает 4 байта.

float

Тип данных чисел с плавающей точкой (или с плавающей запятой). Используется для нецелочисленных расчетов. В Arduino используется например для считывания значений с аналоговых пинов. Диапазон значений от -3.4028235E+38 до 3.4028235E+38,а занимает такая переменная 4 байта.

Точность — 6-7 знаков после запятой.

double

Тип ничем не отличается от типа float и введен для обратной совместимости. На многих других платформах он имеет большую чем у float точность.

string

Тип для хранение текстовых строк. Является массивом символов типа char и символа конца строки ‘\0’ в последнем его элементе. Не путать с классами string и String .

Строка может быть создана и инициализирована несколькими способами:

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

массив

Массив — это набор элементов одного типа с доступом к каждому элементу по индексу.

Нумерация индексов массива начинается с 0.

Ключевое слово void используется при объявлении функции, которая не возвращает значения.

Преобразование типов

Преобразование типов — это приведение значение переменной к другому типа, отличному от типа данной переменной.

Приведение типов делится на явное и неявное.

Пример явного приведения типа:

Пример неявного приведения типа:

Условная конструкция if принимает на вход значение типа boolean , поэтому целочисленное значение переменной a будет приведено к типа boolean .

Источник

Преобразование числовых типов:

Данные:

Однобайтовые типы данных:

принимают любые, возвращают 0 или 1

если принят не 0, то вернётся 1

Целочисленные значения или символы

от -128 до 127

Беззнаковые целочисленные значения

от 0 до 255

Двухбайтовые типы данных:

от -32’768 до 32’767

В Arduino Due, тип int идентичен типу long

Беззнаковые целочисленные значения

от 0 до 65’535

В Arduino Due, тип unsigned int идентичен типу unsigned long

Четырёхбайтовые типы данных:

от -2’147’483’648 до 2’147’483’647

Беззнаковые целочисленные значения

от 0 до 4’294’967’295

Числа с плавающей точкой

от -2’147’483’648,0 до 2’147’483’647,0

Восьмибайтовые типы данных:

Числа с плавающей точкой удвоенной точности

от -9’223’372’036’854’775’808,0 до 9’223’372’036’854’775’807,0

Тип double действует как тип float, кроме Arduino Due

от -9’223’372’036’854’775’808 до 9’223’372’036’854’775’807

Беззнаковые целочисленные значения

от 0 до 18’446’744’073’709’551’615

Типы данных с определяемым размером

Нет принимаемых или возвращаемых значений

Массив A указанного размера, с элементами указанного типа

Массив А указанного типа, без прямого указания размера

Двумерный массив А указанного типа и размера

Двумерный массив А указанного типа, без прямого указания размера

Массив или строка, состоящая из указанного кол-ва символов

Массив или строка, без прямого указания количества символов

Преобразование числовых типов:

Приводит значение A к указанному типу.

Приводит результат A+B к указанному типу.

Сначала приводит A и B , к указанному типу, а потом вычисляет результат A+B .

Приводит указатель A к указанному типу указателя.

Спецификаторы памяти:
(указываются перед типом)

Объявление переменной в виде константы, её можно читать, но нельзя менять, т.к. она хранится в области flash памяти.

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

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

Объявление глобальной переменной, которая определена во внешнем файле.

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

Значения некоторых констант:

Ложь, используются вместо 0
Истина, используется вместо 1

Низкий уровень
Высокий уровень

Конфигурация вывода как вход
Конфигурация вывода как выход
Конфигурация вывода как вход с подтяжкой

Передача младшим битом вперёд
Передача старшим битом вперёд

Тактовая частота Arduino в Гц

Число Пи
Половина числа Пи
Два числа Пи
Число Эйлера

Префиксы:

Запись числа в 2ой системе ( 0b 10101)

Запись числа в 2ой системе ( B 10101)

Запись числа в 8ой системе ( 0 12345)

Запись числа в 16ой системе ( 0x 1234A)

Модификаторы:

Число типа long (12345 L )

Число типа long lond (12345 LL )

Число беззнакового типа (12345 U )

Комбинация модификаторов (12345 UL )

Показатель экспоненты (3 E -5 = 3•10-5)

Переменные, массивы, объекты, указатели, ссылки, . :

Это указание имени и типа переменной.
int A; // объявление переменной А

Это выделение памяти под переменную.
A =1; // определение ранее объявленной A

Действуют постоянно, в любом месте кода.

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

Указывается в одинарных кавычках.
char A=’ Z ‘; // присвоение символа «Z»

Указывается в двойных кавычках.
String A=» Z «; // присвоение строки «XY»

Это переменная с указанием класса, вместо типа, через объект можно обращаться к методам класса

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

int A=5; // создана переменная A = 5
int & C=A; // создана ссылка C на переменную A
A++; C++; // в результате A=7 и C=7
// Ссылку нельзя переопределить: &C=Z;

Указатель, это переменная, значением которой является адрес.

int * Y1=&A; // указателю Y1, передан адрес переменной A
int ( * Y2)(int)=F; // указателю Y2, передан адрес функции F
B=Y1; // получаем адрес переменной A из указателя Y1
B= * Y1; // получаем значение A разыменовывая указатель
// Указатель можно переопределять: Y1=&Z;

Создание альтернативного имени для типа

typedef bool dbl; // создаём свой тип «dbl», как тип bool
dbl A=1; // создаём переменную A типа bool

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

int A[5]; // объявлен массив A из 5 элементов типа int
int A[2]=<7,9>; // объявлен и определён массив A из 2 эл-тов
char A[ ]=»Hi»; // создана строка A, как массив символов

Это объединение нескольких переменных под одним именем.

struct < int A=5; float B=3; >C; // создана структура «С»
int D = C.A; // получаем значение переменной A структуры С
int Z = C.A; // присваиваем Z значение A структуры С

Значения некоторых констант:

Ложь, используются вместо 0
Истина, используется вместо 1

Источник

How to convert int to string on Arduino?

How do I convert an int, n , to a string so that when I send it over the serial, it is sent as a string?

This is what I have so far:

1000 bytes larger, so you may not want to use it if size is a problem.» playground.arduino.cc/Main/Printf

9 Answers 9

You can find more examples here.

use the itoa() function included in stdlib.h

You can simply do:

which will convert n to an ASCII string automatically. See the documentation for Serial.println() .

You just need to wrap it around a String object like this:

You can also do:

This is speed-optimized solution for converting int (signed 16-bit integer) into string.

This implementation avoids using division since 8-bit AVR used for Arduino has no hardware DIV instruction, the compiler translate division into time-consuming repetitive subtractions. Thus the fastest solution is using conditional branches to build the string.

A fixed 7 bytes buffer prepared from beginning in RAM to avoid dynamic allocation. Since it’s only 7 bytes, the cost of fixed RAM usage is considered minimum. To assist compiler, we add register modifier into variable declaration to speed-up execution.

This sketch is compiled to 1,082 bytes of code using avr-gcc which bundled with Arduino v1.0.5 (size of int2str function itself is 594 bytes). Compared with solution using String object which compiled into 2,398 bytes, this implementation can reduce your code size by 1.2 Kb (assumed that you need no other String’s object method, and your number is strict to signed int type).

This function can be optimized further by writing it in proper assembler code.

Источник

ОБОРУДОВАНИЕ
ТЕХНОЛОГИИ
РАЗРАБОТКИ

Блог технической поддержки моих разработок

Урок 30. Текстовые строки в Ардуино. Конвертирование данных в строки и наоборот. Класс String.

В уроке рассказываю о текстовых строках в Ардуино, о классе String, о преобразовании различных типов данных в текстовые строки и об обратной операции — преобразовании строк в числа.

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

Текстовые строки в Ардуино.

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

В Ардуино признаком конца строки является число 0, в текстовом виде ‘\0’. При объявлении строковых переменных в некоторых случаях необходимо явно указывать признак конца строки, а в некоторых он формируется по умолчанию.

Способы объявления и инициализации текстовых строк.

Объявлен символьный массив определенного размера. При заполнении его символами необходимо позаботиться о записи в конце строки байта со значением 0 – признака окончания строки.

Объявлен массив и присвоено значение элементам. В конце строки компилятор прибавит признак конца строки автоматически.

То же самое, только завершающий признак мы объявили явно.

char myStr4 [ ] = “Start”;

Массив инициализирован строковой константой. Компилятор автоматически задаст размер массива и добавит завершающий символ.

char myStr5 [6 ] = “Start”;

То же самое, только размер массива указан явно.

char myStr 6[20 ] = “Start”;

Можно явно указать больший размер массива, например, если он будет использован для строк разной длины.

• Строковые константы объявляются внутри двойных кавычек ( ”Start” ).
• Отдельные символы задаются внутри одинарных ( ‘S’ ).

Длинные строки допускают объявление в таком виде:

char myStr7 [] = “Текстовая строка может быть”
“ объявлена”
“ таким образом”;

Ничего не мешает задавать массивы строк. Поскольку сами строки являются массивами, массивы строк будут двумерными массивами.

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

Управляющие символы.

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

Код символа в HEX (DEC)	Название	Обозначение
0 (0)	Конец строки	\0	Признак конца строки
0D (13)	Возврат каретки	\r	Перемещает курсор в крайнюю левую позицию
0A (10)	Перевод строки	\n	Перемещает курсор на одну строку вниз

Для того чтобы вывести текст с новой строки необходимо использовать символы ‘\r’ и ‘\n’.

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

// управляющие символы
void setup() <
Serial.begin(9600); // скорость 9600
>

void loop() <
Serial.println(«\r\n Begin \r\n next string»
«\r\n 3 empty strings \r\n\r\n\r\n»); // вывод сообщения в нескольких строках
delay(1000);
>

На экране монитора последовательного порта увидим:

Часто управляющие символы ‘\r’ и ‘\n’ применяют для завершения команды в символьном виде, например AT команды. Такой способ управления будем использовать в следующем уроке для драйвера шагового двигателя.

Конвертирование различных типов данных Ардуино в текстовую строку.

Задача преобразования различных типов данных в символьный вид и наоборот возникает:

• при выводе данных на дисплей или индикаторы;
• передаче данных на другие устройства, например компьютер;
• некоторые электронные компоненты требуют обмена данными с помощью AT команд в символьном виде, например GSM модемы, WiFi модули и т.п.

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

Конвертирование данных в строку через встроенные функции классов ввода-вывода.

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

Если необходимо передавать данные через последовательный порт, почему бы не воспользоваться стандартными функциями класса Serial (урок 12).

Преобразование	Функция класса Sreial
int в DEC текст	print(int d)	Преобразует переменную int в строку с десятичным представлением числа
int в DEC текст	print(int d, DEC)	Преобразует переменную int в строку с десятичным представлением числа
int в HEX текст	print(int d, HEX)	Преобразует переменную int в строку с шестнадцатеричным представлением числа
int в OCT текст	print(int d, OCT)	Преобразует переменную int в строку с восьмеричным представлением числа
int в BIN текст	print(int d, BIN)	Преобразует переменную int в строку с двоичным представлением числа
float в текст	print(float d)	Преобразует переменную float в строку с двумя знаками после запятой
float в текст	print(float d, N)	Преобразует переменную float в строку с N знаками после запятой

Например, конвертирование числа int в строку будет выглядеть так.

Преобразование переменной float в строку можно выполнить так.

Преобразование будет выполнено при передаче данных на другое устройство. Функции класса Serial подробно описаны в уроке 12.

Для вывода данных на LCD дисплей с помощью библиотеки LiquidCristal, можно использовать метод print с такими же параметрами.

Конвертирование целочисленных данных в строку через функции itoa, ltoa, ultoa.

Функции простые, позволяют конвертировать числа целых форматов в текстовую строку.

itoa (int data, char* string, int radix); // преобразование int

ltoa (long data, char* string, int radix); // преобразование long

ultoa (unsigned long data, char* string, int radix); // преобразование unsigned long

• data – это конвертируемая переменная;
• char* string – указатель на строку (имя массива);
• radix – система исчисления результата в строке:
  • 10 для DEC;
  • 8 для OCT;
  • 16 для HEX;
  • 2 для BIN.

Например, конвертирование переменой x типа int в строку myStr1 можно сделать так.

itoa(x, myStr1, 10); // в десятичном виде
itoa(x, myStr1, 8); // в восьмеричном виде
itoa(x, myStr1, 16); // в шестнадцатеричном виде
itoa(x, myStr1, 2); // в двоичном виде

Вот программа для проверки работы этих функций.

// проверка преобразования числа в текстовую строку
int x=0; // переменная, которая выводится
char myStr[20]; // текстовый массив

void loop() <
// подготовка буфера строки
for (int i=0; i заполнение пробелами
myStr[18]=’\r’; // возврат каретки
myStr[19]=’\n’; // перевод строки

// преобразование переменной int x
itoa(x, myStr, 10); // int -> DEC
//itoa(x, myStr, 8); // int -> OCT
//itoa(x, myStr, 16); // int -> HEX
//itoa(x, myStr, 2); // int -> BIN

// преобразование переменной long x
//ltoa(x, myStr, 10); // long -> DEC
//ltoa(x, myStr, 8); // long -> OCT
//ltoa(x, myStr, 16); // long -> HEX
//ltoa(x, myStr, 2); // long -> BIN

// преобразование переменной unsigned long x
//ultoa(x, myStr, 10); // long -> DEC
//ultoa(x, myStr, 8); // long -> OCT
//ultoa(x, myStr, 16); // long -> HEX
//ultoa(x, myStr, 2); // long -> BIN

В цикле каждые 0,5 секунд происходит:

• Текстовая строка myStr заполняется пробелами, в конце добавляются управляющие символы возврат каретки и перевод строки.
• Переменная x конвертируется одной из функцией. Результат оказывается в буфере myStr.
• Функция Serial.write(myStr, 20); передает через последовательный порт 20 байтов массива myStr в виде байтов.
• Прибавляется 1 к переменной x.

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

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

Конвертирование данных в строку с помощью функции sprintf.

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

sprint это функция форматированного вывода. Ее широко используют в приложениях на компьютерах. Она дает самые широкие возможности для преобразования данных в строку. Но в системе Ардуино sprintf не поддерживает формат чисел с плавающей запятой.

int sprintf( char *string, const char *format , argument1, argument2 . )

Функция возвращает число преобразованных символов. В случае ошибки возвращает число – 1.

• argument – это переменные, которые необходимо преобразовать;
• format – управляющая строка:

% [флаг] [ширина] тип_формата

Флаг и ширина — необязательные поля.

Тип формата	Тип выходных данных
c	Символ
s	Символьная строка
d, i	Целое десятичное число
u	Целое без знаковое десятичное число
o	Целое восьмеричное число
x	Целое шестнадцатеричное число

Знак	Действие
—	Выравнивание результата влево
+	Выводит знак числа
Пробел	Выводит знак пробел перед положительными числами
0	Заполняет поле 0

Ширина – минимальный размер поля для вывода символов. Если длина числа меньше, то добавляются пробелы. Если перед шириной стоит 0, то добавляются нули.

На примерах из таблицы все должно быть понятно.

int x= 125; int y= 34;

Функция	Выведет в myStr
sprintf(myStr2,»%d»,x );	125
sprintf(myStr2,»%5d»,x );	125
sprintf(myStr2,»%05d»,x );	00125
sprintf(myStr2,»%+05d»,x );	+00125
sprintf(myStr2,»Цикл %d закончен»,x );	Цикл 125 закончен
sprintf(myStr2,»Цикл %d закончен y= %d»,x,y );	Цикл 125 закончен y= 34
sprintf(myStr2,»%o»,x );	175
sprintf(myStr2,»%x»,x );	7d

Можете загрузить следующую программу и проверить работу sprintf в реальном контроллере Ардуино.

// проверка преобразования числа в текстовую строку
// с помощью sprintf
int x=0; // переменная, которая выводится
char myStr[20]; // текстовый массив

void loop() <
// подготовка буфера строки
for (int i=0; i заполнение пробелами
myStr[18]=’\r’; // возврат каретки
myStr[19]=’\n’; // перевод строки

// преобразование переменной int x в строку
sprintf(myStr,»%d»,x ); // int -> DEC
//sprintf(myStr,»%5d»,x ); // int -> DEC
//sprintf(myStr,»%05d»,x ); // int -> DEC
//sprintf(myStr,»%+05d»,x ); // int -> DEC
//sprintf(myStr,»Cycle %d is over»,x ); // int -> DEC с текстом
//sprintf(myStr,»%o»,x ); // int -> OCT
//sprintf(myStr,»%x»,x ); // int -> HEX

Конвертирование данных типа float в текстовую строку.

Самый простой способ преобразования float в текстовую строку – использование функции dtostrf.

char* dtostrf(double data, signed char width, unsigned char prec, char *string)

• data – это конвертируемая переменная;
• width – число значащих разрядов;
• prec – число разрядов после запятой;
• char* string – указатель на строку (имя массива).

float x= 12.728;
dtostrf(x, 2, 3, myStr3); // выводим в строку myStr3 2 разряда до, 3 разряда после запятой

Вот программа для проверки такого способа.

// проверка преобразования числа в текстовую строку
// с помощью dtostrf
float x=0; // переменная, которая выводится
char myStr[20]; // текстовый массив

void loop() <
// подготовка буфера строки
for (int i=0; i заполнение пробелами
myStr[18]=’\r’; // возврат каретки
myStr[19]=’\n’; // перевод строки

// преобразование переменной float x в строку
dtostrf(x, 2, 3, myStr);

Serial.write(myStr, 20);
x+= 0.01;
delay(500);
>

У меня работает.

Конвертирование текстовой строки в различные типы данных.

В следующем разделе речь идет об обратном преобразовании – текстовой строки в число.

Преобразование строки в данные с помощью функций atoi, atol, atof.

Хороший, удобный метод. Функции простые, имеют вид:

int atoi(const char* string); // преобразование в int

long atol(const char* string); // преобразование в long

double atof(const char* string); // преобразование в float

В качестве аргумента функций указывается указатель на строку с числом в десятичном виде. Возвращают – конвертированное значение числа.

Например, преобразование строки myStr4 в переменную x типа int будет выглядеть так.

Для чисел с плавающей запятой.

Вот программа проверки atoi и atol.

// проверка преобразования текстовой строки в число
// с помощью atoi
char myStr[]= «123»; // текстовый массив

void loop() <
Serial.println(atoi(myStr)); // преобразование строки в int
//Serial.println(atol(myStr)); // преобразование строки в long
delay(1000);
>

А в этой программе я проверил работу atof.

// проверка преобразования текстовой строки в число
// с помощью atof
char myStr[]= «123.456»; // текстовый массив

void loop() <
Serial.println(atof(myStr),3); // преобразование строки в float
delay(1000);
>

Конвертирование текстовой строки в числа с помощью функции sscanf.

Функция является обратной функцией для sprintf с такими же недостатками и достоинствами. Но она позволяет конвертировать числа в восьмеричном и шестнадцатеричном форматах. Тип float эта функция на Ардуино не поддерживает.

int sscanf( char *string, const char *format , address1, address2 . )

Все аргументы и форматы такие же, как у sprintf. Только указываются адреса переменных ( address1, address2 . ).

Конвертирование строки myStr5 в переменную x типа int будет выглядеть так.

int x;
sscanf(myStr5,»%d», &x); // для десятичных чисел
sscanf(myStr5,»%o», &x); // для восьмеричных чисел
sscanf(myStr5,»%x», &x); // для шестнадцатеричных чисел

Вот скетч проверки функции для целочисленных операций.

// проверка преобразования текстовой строки в число
// с помощью sscanf
int x;
char myStr[]= «123»; // текстовый массив

void loop() <
sscanf(myStr,»%d», &x);
Serial.println(x); // преобразование строки в int
delay(1000);
>

Класс String Ардуино.

В Ардуино существует класс String. Он предоставляет более широкие возможности для работы с текстовыми строками.

Надо четко различать:

• char myStr [ ] = “Start”; — строка символов, т.е. массив типа char с завершающим признаком в конце;
• String MyStr = Start”; — экземпляр класса String.

Принято имена текстовых строк начинать как обычные переменные с маленькой буквы ( myStr ), а экземпляры String – с большой буквы ( MyStr ).

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

Несколько основных функций класса String.

Я опишу только минимум функций, необходимых для работы с классом String.

String()

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

String MyStr1 = «Start»; // инициализация строковой константы
String MyStr2 = String(‘d’); // преобразование символа в объект String
String MyStr3 = String(«Start»); // преобразование строковой константы в объект String
String MyStr4 = String(MyStr1 + » in 10 sec»); // конкатенация двух строк
String MyStr5 = String(67); // использование целочисленной константы
String MyStr6 = String(analogRead(1), DEC); // использование int с основанием 10
String MyStr7 = String(346, BIN); // использование int с основанием 2
String MyStr8 = String(89, HEX); // использование int с основанием 16
String MyStr9 = String(millis(), DEC); // использование long с основанием системы счисления

При создании объекта из числа, сформированная строка будет содержать ASCII (символьное) представление числа. По умолчанию используется десятичная система счисления, но можно указать другую. Т.е. функция String может осуществлять преобразование целочисленных данных в текстовую строку.

toCharArray(*buf, length)

Копирует текст экземпляра класса String в указанный массив.

• buf – указатель на массив;
• length – количество символов.

MyStr.toCharArray(myStr, 10); // копируем 10 символов в массив myStr

int length()

Функция возвращает длину строки String в символах без учета завершающего признака нуля.

int len =MyStr.length(); // получаем длину строки MyStr

long toInt()

Функция преобразовывает объект String в целое число.

int x = MyStr.toInt(); // конвертирование строки MyStr в int

Конвертирование данных в строку String.

Для целочисленных форматов все очень просто.

String MyStr;
int x;
MyStr= String(x, DEC); // для десятичных чисел
MyStr= String(x, HEX); // для шестнадцатеричных чисел
MyStr= String(x, BIN); // для двоичных чисел

Программа для проверки.

// проверка преобразования числа в String
int x=0; // переменная, которая выводится
String MyStr;

MyStr= String(x, DEC); // int -> DEC
//MyStr= String(x, HEX); // int -> HEX
//MyStr= String(x, BIN); // int -> BIN

Для плавающей запятой надо использовать функцию dtostrf(). С помощью нее получить строку-массив, а затем занести ее в объект String.

float x=2.789;
String MyStr;
char myStr8[10];
dtostrf(x, 2, 3, myStr8); // выводим в строку myStr8 2 разряда до, 3 разряда после запятой
MyStr = myStr8;

Программа для проверки преобразования float.

// проверка преобразования числа в String
float x=0; // переменная, которая выводится
String MyStr;
char myStr[10];

dtostrf(x, 2, 3, myStr); // выводим в строку myStr 2 разряда до, 3 разряда после запятой
MyStr = myStr;

Serial.println(MyStr);
x += 0.01;
delay(500);
>

Конвертирование строки String в различные типы данных.

Для целых чисел используем функцию toInt().

String MyStr = «123»;
int x = MyStr.toInt();

// проверка преобразования String в число
// с помощью toInt
String MyStr = «123»;

void loop() <
Serial.println(MyStr.toInt()); // преобразование строки в int
delay(1000);
>

Для плавающей запятой.

Получим данные из объекта String в массив и выполним преобразование функцией atof().

String MyStr = «34.123»;
char myStr8[10];
MyStr.toCharArray(myStr8, MyStr.length()); // копирование String в массив myStr8
float x = atof(myStr8); // преобразование в float

Программа для проверки.

// проверка преобразования String в число
// с помощью toInt
String MyStr = «34.123»;
char myStr[10];

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

Источник