Разделение строки Arduino
Насколько я знаю, язык программирования Arduino — C++. Нагуглил код по этой же проблеме:
Дизайн сайта / логотип © 2023 Stack Exchange Inc; пользовательские материалы лицензированы в соответствии с CC BY-SA . rev 2023.3.11.43304
Нажимая «Принять все файлы cookie» вы соглашаетесь, что Stack Exchange может хранить файлы cookie на вашем устройстве и раскрывать информацию в соответствии с нашей Политикой в отношении файлов cookie.
String-строки
Мы с вами уже познакомились с символами в уроке про типы данных. Как в обычной жизни, одиночные символы соединяются в слова и строки – это текст, заключённый в двойные кавычки: «Hello, World!» . У нас есть два набора инструментов для работы с ними:
- Статические строки – они же массивы символов char , являются стандартными для языка C/C++ и работают одинаково на любой платформе. О них поговорим в следующем уроке.
- Динамические String -строки, в Arduino за них отвечает отдельная библиотека, которая входит в состав “ядра”. Эти строки просты и удобны в использовании, поэтому сначала разберём работу с ними.
Базовый синтаксис
Создание String
Строка создаётся как обычная переменная:
При создании также можно присвоить строке значение. String позволяет автоматически преобразовывать любой стандартный тип данных в строку:
Помимо такой инициализации, есть ещё вариант с конструктором, он более гибкий: в скобках можно указать значение, а для некоторых типов данных доступны дополнительные настройки:
Более того, данный способ работает быстрее присваивания, так как выделяет память под строку один раз. В варианте с присваиванием сначала выделяется пустая строка, а затем увеличивается под новые данные.
Сложение String
К строке можно прибавить любой тип данных, так же как при создании, по одному действию в строке кода:
Также String позволяет складывать строки между собой при помощи оператора + . В тексте ниже данные имеют любой тип, с которым String поддерживает сложение (см. выше):
- Одним из слагаемых должна быть строка, как выше: стринг + данные или данные + стринг
- Операция сложения возвращает строку обратно, что позволяет сделать “каскад” из таких сложений и собрать строку “одной строкой кода”, сборка происходит слева направо: стринг + данные1 + данные2 или данные1 + стринг + данные2 + данные3
- Результат всей суммы можно:
- Приравнять к String: стринг = стринг + данные1 + данные2
- Отправить в функцию, которая принимает String: f(стринг + данные1 + данные2)
- И так далее
Для сборки строки данный вариант менее предпочтительный, чем предыдущий с += . Ниже разберёмся, почему.
Доступ к символам
К строке можно обратиться как к массиву и прочитать или изменить символ по порядку:
Сравнение String
Стринги можно сравнивать между собой и с обычными строками ( const char* ):
Остальные методы
Рассмотрим все библиотечные методы для работы со строками, они применяются к строке через точку. В рассмотренных ниже примерах “тестовая” строка называется myString. Также оставлю некоторые комментарии по оптимизации.
myString.compareTo(myString2)
- Возвращает отрицательное число, если myString идёт до myString2
- Возвращает положительное число, если myString идёт после myString2
- Возвращает 0, если строки одинаковы
myString.replace(substring1, substring2) – в строке myString заменяет последовательность символов substring1 на substring2.
myString.substring(from) и myString.substring(from, to) – возвращает подстроку, содержащуюся в myString с позиции from и до конца, либо до позиции to
myString.toInt() – конвертирует и возвращает содержимое строки в тип данных int
Проблемы и оптимизация String
Преимущество стрингов заключается в том, что с ними очень легко и удобно работать: собирать из других строк и переменных любых типов, складывать между собой, делить на подстроки и так далее. За удобство приходится платить: String является динамическим объектом (читай урок про динамическую память), что влечёт за собой некоторые проблемы. Также на форумах часто критикуют String и предлагают использовать вместо них обычные си-строки, давайте рассмотрим всё вместе:
- String – тяжёлый. Несомненно – использование String-строк сразу добавляет пару килобайт Flash памяти к весу программы, так как для работы с ними используется менеджер памяти (встроенная библиотека). В то же время, если в программе уже используется динамическое выделение памяти – добавление String будет заметно не так сильно. На этом данная проблема заканчивается, потому что если открыть реализацию библиотеки String, то можно увидеть, что все действия со строками выполняются при помощи стандартных строковых функций языка Си (подробнее – в следующем уроке).
- String – медленный. Да, когда строка меняет свою длину – она начинает менять свой размер и даже место в оперативной памяти микроконтроллера. Переписывание и перераспределение памяти происходит отнюдь не мгновенно, поэтому операции со String выполняются относительно долго: сотни микросекунд. Если собирать строку посимвольно – каждая прибавка будет выполняться дольше, чем хотелось бы! Этого можно избежать, используя метод reserve() , который зарезервирует память, чтобы увеличение строки происходило без выделения памяти (подробнее об этом ниже). Если место под строку зарезервировано – операции со строкой будут выполняться с такой же скоростью, как и с обычными строками, потому что для них используются те же стандартные строковые функции.
- String – опасный. Всё верно, неаккуратная работа со String может привести к сильной фрагментации памяти, неправильной работе программы и даже полному её зависанию. В то же время, если понимать как работают стринги и использовать эффективные и безопасные конструкции в работе с ними – можно избежать абсолютно всех проблем!
Использование памяти
Несмотря на то, что строка – это динамический инструмент, в реализации Arduino она может только увеличиваться. Это означает, что если у нас была длинная строка, а затем мы её обнулили – места в памяти она не стала занимать меньше! То есть
Следующая созданная стринга будет размещена в памяти сразу за предыдущей. Возникает вопрос: а как тогда удалить строку и освободить память? Очень просто:
- Если строка создана глобально – никак, в библиотеке не предусмотрено публичного инструмента для очистки строки.
- Если строка создана локально – она автоматически выгрузится из памяти, когда код дойдёт до закрывающей фигурной скобки, за которой она уже не существует.
Сложение строк
Самый плохой вариант, который только можно себе представить, выглядит вот так:
Так делать нельзя, но тем не менее, на форумах очень часто можно встретить этот вариант. Здесь плохо всё: создаётся несколько “временных” экземпляров строки, под каждый выделяется память, тратится время, в результате каждый кусок начинает смещаться по памяти вперёд на новое место и изначальная строка прыгает в самый конец этого “паравозика”, образуя “дырку” в памяти (фрагментацию)!
Для сборки строки из нескольких частей рекомендуется использовать исключительно вариант с построчным прибавлением += . Пусть он не такой визуально компактный, как сложение “в одной строке кода”, но он позволяет избежать создания лишних экземпляров String, лишних перераспределений памяти и самое главное – не приводит к её фрагментации и выполняется гораздо быстрее:
Фрагментация памяти
Тут есть ещё один важный момент: если в процессе такой сборки строки создать ещё одну строку – это приведёт к сильной фрагментации памяти! Например:
В конце выполнения этого кода собранная строка состоит условно из 25 символов и должна занимать в памяти 25 байт. Но с начала выполнения этого кода свободная память уменьшилась на 50+5 байт! Как и почему это произошло:
- Перед созданием второй строки у нас уже есть строка, представим её как блок памяти [——str——]
- Мы создаём ещё одну строку, она располагается в памяти сразу за предыдущей строкой (так работает менеджер памяти) [——str——][—str2—]
- Теперь мы прибавляем к первой строке вторую: вторая строка остаётся в памяти, она никуда не пропадает, а первой нужно больше места. Поэтому менеджер памяти переносит первую строку на место сразу после второй и в памяти остаётся “дырка”! [ дырка ][—str2—][——str-str2——]
- В итоге “край” свободной памяти смещается на длину первой строки плюс длину второй строки. Беда!
С небольшими строками и кучей свободной памяти данная ситуация нам ничем не страшна, но если вы неправильно собираете например веб-страницу или другой ответ серверу – строка может начать занимать в несколько раз больше места, чем должна, и свободная оперативная память просто закончится!
Аналогичная ситуация произойдёт в том числе при вот такой записи, здесь тоже будет создана новая стринга в процессе сборки первой:
- Избегать создания новых строк в процессе работы с уже имеющимися
- Резервировать место под “прибавку”, прибавлять, а затем удалять вторую строку из памяти. Рассмотрим этот вариант
Сценарий первый, строка создаётся как переменная
Мы поместили создание второй строки в отдельный блок кода, чтобы она автоматически удалилась из памяти после выхода из этого блока.
Сценарий второй, преобразование
Как это работает:
- Была строка [——str——]
- Мы её расширили [——str—— ]
- Создали вторую строку [——str—— ][—str2—]
- Переписали [——str——str2—][—str2—]
- Удалили временную строку [——str——str2—]
- Осталась сумма и никаких препятствий в памяти
Резервирование памяти
Вернёмся к первому примеру: можно ещё сильнее оптимизировать сборку строки, если сразу зарезервировать место. Мы не знаем, какой длины она будет, но можем прикинуть. Можно даже зарезервировать чуть больше, это не так страшно:
Теперь каждое прибавление не будет приводить к перераспределению памяти и код выполнится быстрее. Также создание промежуточных строк не будет приводить к фрагментации памяти, потому что строке есть куда расти!
Оптимизация памяти
Забегая немного вперёд – текст в двойных кавычках хранится и в программной памяти программы (которой много), и в оперативной (которой мало). В уроке про PROGMEM мы рассмотрим несколько способов оптимизации памяти, но уже сейчас можно начать применять макрос F() – данный макрос позволяет хранить строку только в программной памяти и доставать её оттуда только для сложения со стрингой. Например после выполнения вот такого безобидного кода
Текст «Hello» окажется продублирован в памяти микроконтроллера целых 3 раза!
- Текст всегда хранится в памяти программы
- При запуске МК текст переписывается в оперативную память, чтобы можно было иметь к нему доступ. Находится там на всём протяжении работы программы
- Мы создали стринг-строку, в которую скопировали этот текст. Копия будет находиться в памяти, пока строка не будет удалена из памяти
Если обернуть текст в макрос F() – он будет загружаться из программной памяти напрямую в строку, и удалится из неё вместе со строкой:
Таким образом этот макрос крайне рекомендуется использовать для сборки строки с участием строковых констант. Вернёмся к нашему примеру:
Именно так и рекомендуется собирать строки.
Передача в функции
Функции очень многих библиотек для Arduino принимают String-строки. Это может быть вывод на дисплей, отправка в веб и многое другое. Если посмотреть реализацию этих функций – они принимают тип данных String& или const String& . Это – ссылка на строку, подробнее читайте в уроке про указатели и ссылки.
Как это работает и зачем: допустим вам нужна функция, которая принимает строку и что то с ней делает, например выводит в монитор порта. Это будет выглядеть примерно так:
Проблема в том, что когда мы передадим в эту функцию строку
она будет продублирована в памяти, то есть внутри нашей функции будет копия переданной строки. Если строка большая, а свободной памяти мало – быть беде. Если передать строку по ссылке – внутри функции окажется именно наша строка, лишней копии не будет.
Рекомендуется делать именно так.
Далее, если вы захотите помимо String-строк отправлять в свою функцию строковые константы (текст в кавычках) или текст внутри макроса F() для экономии памяти, то нужно будет добавить слово const :
Такая конструкция сможет эффективно принимать любые строковые данные для дальнейшей работы:
Сборка строки в отдельной функции
Довольно частый сценарий – сделать себе функцию, которая будет собирать строку из каких то данных, переданных в функцию или из глобальной области. Например, для дальнейшей отправки этой строки куда-нибудь. Это можно сделать двумя способами, первый очевидный: сделать функцию, которая возвращает тип String , внутри неё создать строку, заполнить чем нужно и вернуть обратно:
В этом случае не происходит фрагментации памяти, строка не дублируется в памяти, так как библиотека String предусматривает такой сценарий и буквально перемещает строку без создания копии. Но есть вариант лучше: создать строку там где она нужна, и передать её в функцию, которая изменит строку. Передавать будем по адресу, чтобы внутри новой функции это была та же самая строка. Возвращать из функции ничего не нужно:
Такой вариант работает чуточку быстрее (на пару десятков мкс на AVR) и использует чуть меньше оперативной памяти в рамках всей конструкции (около 10 байт на AVR по моим тестам).
Другие библиотеки
Ради интереса я написал свою версию String, но без использования динамической памяти: максимальный размер строки задаётся при её создании, это позволяет сэкономить в сумме около 2 кБ Flash на одних и тех же операциях со строкой. Библиотека имеет такой же набор методов и возможностей, как у String, что позволяет легко заменить стандартные стринги на мои, а также там есть несколько дополнительных фишек. Библиотека называется mString, документацию и примеры смотрите на GitHub.
How do I split an incoming string?
How would I split these values up, and convert them to an integer?
12 Answers 12
Contrarily to other answers, I’d rather stay away from String for the following reasons:
- dynamic memory usage (that may quickly lead to heap fragmentation and memory exhaustion)
- quite slow due to construction/destruction/assignment operators
In an embedded environment like Arduino (even for a Mega that has more SRAM), I’d rather use standard C functions:
-
: search for a character in a C string (i.e. char * ) : splits a C string into substrings, based on a separator character : converts a C string to an int
That would lead to the following code sample:
The advantage here is that no dynamic memory allocation takes place; you can even declare input as a local variable inside a function that would read the commands and execute them; once the function is returned the size occupied by input (in the stack) is recovered.
This function can be used to separate a string into pieces based on what the separating character is.
Convert String to int
This Chunk of code takes a string and separates it based on a given character and returns The item between the separating character
You could do something like the following, but please take into account several things:
If you use readStringUntil() , it will wait until it receives the character or timeouts. Thus, with your current string, the last position will last a little longer, as it has to wait. You can add a trailing & to avoid this timout. You can easily check this behavior in your monitor, try to send the string with and without the extra & and you will see such timeout delay.
You actually do not need the servo index, you can just send your string of positions, and get the servo index by the value position in the string, something like: 90&80&180& . If you use the servo index, maybe you want to check it (convert to int , and then match the loop index i) to ensure that nothing went wrong with your message.
You have to check that the returning string from readStringUntil is not empty. If the function timeouts, you didn’t receive enough data, and thus any attempt to extract your int values will produce strange results.