Master Arduino Characters and Strings

In this chapter, we explore the Arduino Characters , unsigned char, String, and char[] data types in Arduino, explaining how they are used to store and manipulate characters and strings. Whether you’re handling single characters or working with complex text, this guide will teach you the essentials of string manipulation in Arduino with clear explanations and practical examples.

Syntax Table: Arduino Characters and Strings

char (Character) in Arduino

In Arduino, char is a data type that is used to store a single character. Characters are enclosed in single quotes (e.g., ‘A’, ‘b’, or ‘1’). The char data type stores the ASCII value of the character, which is an integer that represents a specific character from the ASCII table.

Use purpose
The char data type is used for:

• Storing single characters: It is useful when you need to handle individual letters, digits, or symbols.
• Working with strings: In Arduino, strings are often stored as arrays of characters (char[]), so understanding the char data type is crucial when dealing with text or characters.
• Displaying characters: It can be used to send characters to displays, serial monitors, or other output devices.

Arduino Syntax use
char variableName = ‘character’;

Arduino Syntax Explanation

• char: Defines a variable of type char to store a single character.
• variableName: The name of the variable that will hold the character.
• ‘character’: The actual character you want to store, enclosed in single quotes.

Arduino code Example

char letter = 'A';
char digit = '5';
void setup() {
  Serial.begin(9600);
  Serial.print("The letter is: ");
  Serial.println(letter);
  Serial.print("The digit is: ");
  Serial.println(digit);
}
void loop() {
  // No code needed here
}

Code Explanation

• In this example, two char variables are declared: letter stores the character ‘A’, and digit stores the character ‘5’.
• The Serial.print and Serial.println functions are used to display the values of these char variables on the serial monitor.
• This demonstrates how individual characters can be stored and printed in Arduino.

Notes

• The char data type holds the ASCII value of the character. For example, ‘A’ is stored as the ASCII value 65, and ‘5’ is stored as 53.
• A char variable can only hold one character at a time. To work with multiple characters, you need to use an array of characters (e.g., char[]), which is how strings are represented in Arduino.
• You can perform arithmetic operations on char variables since they are essentially stored as numbers (ASCII values). For instance, you can add or subtract numbers from characters to shift them in the ASCII table.

unsigned char (Unsigned Character) in Arduino

The unsigned char in Arduino is a data type used to store single byte values ranging from 0 to 255. Unlike the char data type, which can hold both positive and negative values (-128 to 127), the unsigned char can only store non-negative values. It is often used when working with raw data that doesn’t require negative values, such as binary data or when interfacing with hardware that uses byte-level operations.

Use purpose
The unsigned char is used for:

• Storing single-byte values: It is ideal for storing numbers that fit within the range of 0 to 255.
• Handling raw data: Commonly used when working with raw binary data, bytes, or hardware communication protocols (e.g., serial communication, sensors, etc.).
• Memory-efficient data storage: Since unsigned char uses just one byte of memory, it is useful when you need to store multiple small numbers efficiently.

Arduino Syntax use
unsigned char variableName = value;

Arduino Syntax Explanation

• unsigned char: Defines a variable as an unsigned character, which can store values between 0 and 255.
• variableName: The name of the variable.
• value: The initial value to be stored in the variable, within the range 0-255.

Arduino code Example

unsigned char sensorValue = 150;
void setup() {
  Serial.begin(9600);
  Serial.print("The sensor value is: ");
  Serial.println(sensorValue);
}
void loop() {
  // No code needed here
}

Code Explanation

• The variable sensorValue is declared as an unsigned char with a value of 150. Since unsigned char can hold values from 0 to 255, this is a valid assignment.
• The value of sensorValue is printed to the serial monitor using the Serial.print and Serial.println functions.
• This example demonstrates how to declare and use an unsigned char to store and display a byte-sized value.

Notes

• Range: The unsigned char can only hold values between 0 and 255. If you assign a value outside this range, it will wrap around. For example, assigning 256 will result in 0, and assigning -1 will result in 255.
• Memory efficiency: unsigned char uses only one byte of memory, making it efficient for storing small values.
• Use in hardware communication: It is often used when working with low-level protocols like SPI or I2C, or when manipulating raw data that fits within a byte.

String (String Object) in Arduino

In Arduino, String is a data type used to store and manipulate sequences of characters. Unlike character arrays (char[]), the String object is a more flexible and powerful way to handle text and character strings. It allows for dynamic memory allocation, which means you can modify the content of a String during runtime (e.g., adding or removing characters). It also provides built-in functions for string manipulation, making it easier to work with text.

Use purpose
The String object is used for:

• Storing text: It can hold and manipulate large amounts of text, making it ideal for handling user input or sensor data in the form of text.
• String manipulation: Provides useful functions like concatenation (joining), substring extraction, and comparison, simplifying tasks that involve working with strings.
• Dynamic memory management: Unlike character arrays, which have a fixed size, String objects can grow or shrink as needed.

Arduino Syntax use
String variableName = “text”;

Arduino Syntax Explanation

• String: Defines a variable of type String to store a sequence of characters.
• variableName: The name of the String variable.
• “text”: The string of characters to be stored, enclosed in double quotes.

Arduino code Example

String message = "Hello, Arduino!";
String name = "User";
void setup() {
  Serial.begin(9600);
  // Print the message to the serial monitor
  Serial.println(message);
  // Concatenate strings
  String greeting = message + " Welcome, " + name + "!";
  Serial.println(greeting);
}
void loop() {
  // No code needed here
}

Code Explanation

• In this example, the String object message holds the text “Hello, Arduino!” and name holds “User”.
• The String object greeting is created by concatenating the message, additional text ” Welcome, “, and name using the + operator. This flexibility makes String objects very useful for manipulating text.
• The concatenated greeting is then printed to the serial monitor, demonstrating how to use String for dynamic text generation.

Notes

• Memory usage: String objects dynamically allocate memory on the heap, which can lead to memory fragmentation over time, especially on boards with limited memory like the Arduino Uno. This is something to be aware of in memory-constrained applications.
• String methods: The String class offers many useful methods, such as:
  • .length(): Returns the length of the string.
  • .toUpperCase(): Converts the string to uppercase.
  • .substring(start, end): Extracts a portion of the string.
• Comparison with char[]: While char[] is more memory efficient and doesn’t require dynamic memory, the String object provides a much easier and more intuitive way to work with text, especially for beginners.

char[] (Character Array or C-string) in Arduino

A char[] in Arduino is a character array, often referred to as a C-string. It is a sequence of characters stored in contiguous memory locations and terminated by a null character (‘\0’). This null terminator marks the end of the string. Unlike the String object, a char[] has a fixed size, which must be specified when the array is declared. C-strings are more memory-efficient than String objects, but they can be more complex to work with because they don’t offer built-in string manipulation functions.

Use purpose
The char[] (C-string) is used for:

• Storing text in a memory-efficient way: Since C-strings use a fixed amount of memory, they are ideal for low-memory devices like Arduino boards.
• Interfacing with C libraries: Many C libraries (such as for serial communication or display functions) use char[] as the preferred data type for strings.
• Direct memory control: Since you have direct control over the memory allocation, it’s useful in situations where you need to manage memory tightly.

Arduino Syntax use
char variableName[size] = “text”;

Arduino Syntax Explanation

• char: Declares a variable of type char[], which will hold an array of characters.
• variableName: The name of the character array.
• size: The number of elements (characters) the array can hold, including the null terminator.
• “text”: The sequence of characters to be stored, enclosed in double quotes.

Arduino code Example

char greeting[20] = "Hello, Arduino!";
void setup() {
  Serial.begin(9600);
  // Print the greeting
  Serial.println(greeting);
  // Change the value of the character array
  greeting[7] = 'W';
  greeting[8] = 'o';
  greeting[9] = 'r';
  greeting[10] = 'l';
  greeting[11] = 'd';
  greeting[12] = '\0';  // Manually adding the null terminator
  // Print the modified greeting
  Serial.println(greeting);
}
void loop() {
  // No code needed here
}

Code Explanation

• In this example, the char[] array greeting is declared with a size of 20 characters, which includes the characters for “Hello, Arduino!” plus extra space for modifications.
• The first Serial.println(greeting) prints the original string.
• The program then modifies specific characters in the array starting from index 7, changing “Arduino!” to “World”, and manually adds a null terminator at the end to ensure the string is properly terminated.
• The modified string is then printed to the serial monitor, showing “Hello, World”.

Notes

• Null terminator: A char[] string must always end with a ‘\0’ (null terminator) to indicate the end of the string. If the null terminator is not present, the program may read beyond the intended string, leading to unpredictable behavior.
• Fixed size: The size of the char[] array must be defined at the time of declaration and cannot be changed later. If the string is too long for the array, it can cause memory corruption or unexpected behavior.
• Efficiency: char[] is more memory-efficient compared to String objects, especially on memory-constrained devices like Arduino Uno.
• No built-in functions: Unlike String objects, char[] does not offer built-in methods for string manipulation. Instead, functions from the C standard library, like strcpy(), strlen(), or strcat(), must be used.

string.length() (String Length) in Arduino

In Arduino, string.length() is a function used with String objects to determine the number of characters in the string. This function counts the characters in the string but does not include the null terminator (\0). It is useful for determining how many characters are stored in a String, especially when you need to perform operations like trimming, splitting, or validating user input.

Use purpose
The string.length() function is used for:

• Determining string length: To find out how many characters are in a string.
• Conditional operations: To control logic based on the length of a string, such as trimming long text or validating input length.
• Efficient memory usage: Helpful when working with strings that may need to be limited to a certain size for memory optimization or formatting purposes.

Arduino Syntax use
stringVariable.length();

Arduino Syntax Explanation

• stringVariable: The String object whose length you want to measure.
• .length(): This function returns an integer representing the number of characters in the string (excluding the null terminator).

Arduino code Example

String greeting = "Hello, Arduino!";
void setup() {
  Serial.begin(9600);
  // Get the length of the greeting string
  int length = greeting.length();
  // Print the length of the string
  Serial.print("The length of the string is: ");
  Serial.println(length);
}
void loop() {
  // No code needed here
}

Code Explanation

• The String object greeting is initialized with the text “Hello, Arduino!”.
• The length() function is called on the greeting string to determine how many characters it contains.
• The length of the string is then printed to the serial monitor. In this case, it will output “The length of the string is: 15”, since there are 15 characters in “Hello, Arduino!” (spaces and punctuation are also counted).

Notes

• Excludes null terminator: The length() function returns the number of characters in the string, excluding the ‘\0’ (null terminator).
• Includes all visible characters: The function counts spaces, punctuation, and special characters.
• Use with caution for large strings: Since String objects dynamically allocate memory, frequently manipulating large strings may cause memory fragmentation on devices with limited RAM (like Arduino Uno).

string.concat() (String Concatenation) in Arduino

In Arduino, string.concat() is a function used with String objects to concatenate (combine) two strings together. It appends the content of another string, character, or number to the end of the original String object. This function is useful when you need to merge text, combine variables with strings, or format messages dynamically.

Use purpose
The string.concat() function is used for:

• Joining strings: Combine multiple strings into a single String object.
• Adding characters or numbers: Easily append individual characters or numerical values to a string.
• Creating dynamic text: Useful for building messages that incorporate data such as sensor readings, user input, or time-based information.

Arduino Syntax use
stringVariable.concat(string2);

Arduino Syntax Explanation

• stringVariable: The original String object where the second string will be appended.
• .concat(): The function that appends another string, character, or number to the original string.
• string2: The second string, character, or number to concatenate to the original String.

Arduino code Example

String greeting = "Hello, ";
String name = "Arduino";
void setup() {
  Serial.begin(9600);
  // Concatenate the two strings
  greeting.concat(name);
  // Print the combined string
  Serial.println(greeting);
}
void loop() {
  // No code needed here
}

Code Explanation

• In this example, the String object greeting is initialized with the text “Hello, “ and name is initialized with “Arduino”.
• The concat() function is used to append the name string to the greeting string, creating the full message “Hello, Arduino”.
• The combined string is then printed to the serial monitor, demonstrating how string.concat() can merge two strings.

Notes

• Multiple data types: You can use string.concat() to append not only other strings but also characters, integers, and floating-point numbers to a String object.
• Memory considerations: The String class uses dynamic memory allocation. While concat() is easy to use, be cautious when repeatedly concatenating strings, as it may lead to memory fragmentation on devices with limited RAM, such as the Arduino Uno.
• Alternative approach: You can also concatenate strings using the + operator (e.g., greeting = greeting + name;), which provides a similar effect and is sometimes more readable.

string.toUpperCase() (Convert String to Uppercase) in Arduino

The string.toUpperCase() function in Arduino is used to convert all the characters in a String object to uppercase. It modifies the original string, transforming any lowercase letters into their uppercase equivalents. This is useful when you need to normalize text input, display text consistently, or process strings for comparison or formatting purposes.

Use purpose
The string.toUpperCase() function is used for:

• Text normalization: Ensures that all text is in uppercase, which can be helpful for case-insensitive comparisons.
• Formatting output: Converts text to uppercase for displaying messages or formatting data.
• User input handling: Useful when dealing with text input, especially when a uniform format is required (such as serial commands or case-insensitive processing).

Arduino Syntax use
stringVariable.toUpperCase();

Arduino Syntax Explanation

• stringVariable: The String object whose characters will be converted to uppercase.
• .toUpperCase(): This function converts the string to uppercase and modifies the original String.

Arduino code Example

String message = "Hello, Arduino!";
void setup() {
  Serial.begin(9600);
  // Convert the message to uppercase
  message.toUpperCase();
  // Print the converted string
  Serial.println(message);
}
void loop() {
  // No code needed here
}

Code Explanation

• In this example, the String object message is initialized with the text “Hello, Arduino!”.
• The toUpperCase() function converts all lowercase letters in the string to uppercase, transforming the text to “HELLO, ARDUINO!”.
• The modified string is then printed to the serial monitor, demonstrating how the toUpperCase() function converts and updates the string.

Notes

• Modifies the original string: The toUpperCase() function directly modifies the original String object.
• Only affects alphabetic characters: Non-alphabetic characters (such as numbers, punctuation, and spaces) are not affected by this function.
• Useful for case-insensitive comparisons: If you need to compare strings in a case-insensitive manner, converting both strings to uppercase using toUpperCase() ensures they are compared consistently.

string.toLowerCase() (Convert String to Lowercase) in Arduino

The string.toLowerCase() function in Arduino is used to convert all characters in a String object to lowercase. It modifies the original string by transforming all uppercase letters into their lowercase equivalents. This function is useful for ensuring uniformity in text input, making case-insensitive comparisons, or preparing strings for display or further processing.

Use purpose
The string.toLowerCase() function is used for:

• Text normalization: Ensures that text is all in lowercase, useful for consistent formatting or case-insensitive processing.
• Case-insensitive comparison: Helps when comparing strings where case should be ignored.
• Formatting output: Converts text to lowercase when needed for output displays or message formatting.

Arduino Syntax use
stringVariable.toLowerCase();

Arduino Syntax Explanation

• stringVariable: The String object whose characters you want to convert to lowercase.
• .toLowerCase(): This function converts all alphabetic characters in the string to lowercase and modifies the original string.

Arduino code Example

String message = "HELLO, ARDUINO!";
void setup() {
  Serial.begin(9600);
  // Convert the message to lowercase
  message.toLowerCase();
  // Print the converted string
  Serial.println(message);
}
void loop() {
  // No code needed here
}

Code Explanation

• The String object message is initialized with the text “HELLO, ARDUINO!”.
• The toLowerCase() function converts all uppercase alphabetic characters to lowercase, transforming the string to “hello, arduino!”.
• The modified string is printed to the serial monitor, demonstrating how the toLowerCase() function works.

Notes

• Modifies the original string: The toLowerCase() function directly modifies the String object it is called on.
• Non-alphabetic characters unaffected: Only alphabetic characters (A-Z) are converted. Numbers, punctuation, and other special characters remain unchanged.
• Useful for case-insensitive operations: Use this function when performing operations where the case of the characters should not matter, such as user input or text comparison.

string.substring() (Substring Extraction) in Arduino

The string.substring() function in Arduino is used to extract a portion of a string from a specified start position to an optional end position. This function allows you to create a new string from part of an existing String object. It’s particularly useful when you need to extract specific data from a larger string, such as parsing sensor data, user input, or formatted text.

Use purpose
The string.substring() function is used for:

• Extracting specific parts of a string: For example, retrieving a word, a set of characters, or a portion of data from a larger string.
• Data parsing: Useful for extracting segments from formatted text like dates, times, or sensor readings.
• Manipulating strings: Allows you to work with only the required part of a string for further processing.

Arduino Syntax use
stringVariable.substring(startIndex);
stringVariable.substring(startIndex, endIndex);

Arduino Syntax Explanation

• stringVariable: The String object from which you want to extract the substring.
• startIndex: The position (index) in the string where the substring begins. Indexing starts from 0.
• endIndex (optional): The position where the substring ends, but not including the character at this index. If omitted, the substring extends to the end of the string.

Arduino code Example

String message = "Hello, Arduino!";
void setup() {
  Serial.begin(9600);
  // Extract substring starting from index 7 to the end
  String part1 = message.substring(7);
  Serial.println(part1);  // Output: Arduino!
  // Extract substring from index 7 to 13
  String part2 = message.substring(7, 13);
  Serial.println(part2);  // Output: Arduino
}
void loop() {
  // No code needed here
}

Code Explanation

• The String object message is initialized with the text “Hello, Arduino!”.
• The substring(7) function extracts the portion of the string starting from index 7 (the character ‘A’) to the end, resulting in “Arduino!”.
• The substring(7, 13) function extracts the portion of the string starting from index 7 and ending at index 13 (not including index 13), resulting in “Arduino”.
• The extracted substrings are printed to the serial monitor.

Notes

• Indexing starts from 0: The first character in the string is at position 0. So, substring(7) begins at the 8th character.
• End index exclusive: If you specify an end index, the character at that position is not included in the substring.
• Out of range indices: If the start or end indices are out of range (e.g., negative values or values greater than the string’s length), the function may not behave as expected.

string.indexOf() (Find Character or Substring in String) in Arduino

The string.indexOf() function in Arduino is used to find the position of a specific character or substring within a String object. It returns the index (position) of the first occurrence of the character or substring. If the character or substring is not found, the function returns -1. This function is useful for searching within a string and extracting or manipulating text based on the position of characters or substrings.

Use purpose
The string.indexOf() function is used for:

• Finding characters or substrings: To locate the position of a specific character or sequence of characters within a string.
• Data parsing: Useful for finding delimiters or markers within text, such as commas, spaces, or special characters.
• Conditional string processing: Helps determine whether a character or substring exists within a string and where it is located.

Arduino Syntax use
stringVariable.indexOf(character);
stringVariable.indexOf(character, fromIndex);
stringVariable.indexOf(substring);
stringVariable.indexOf(substring, fromIndex);

Arduino Syntax Explanation

• stringVariable: The String object in which to search for the character or substring.
• character: The character you want to find in the string.
• substring: The substring you want to find in the string.
• fromIndex (optional): The position from which to start the search. If omitted, the search starts from the beginning of the string.

Arduino code Example

String message = "Hello, Arduino!";
void setup() {
  Serial.begin(9600);
  // Find the position of the character 'A'
  int index1 = message.indexOf('A');
  Serial.print("Position of 'A': ");
  Serial.println(index1);  // Output: 7
  // Find the position of the substring "Arduino"
  int index2 = message.indexOf("Arduino");
  Serial.print("Position of 'Arduino': ");
  Serial.println(index2);  // Output: 7
  // Find the position of 'o' starting from index 5
  int index3 = message.indexOf('o', 5);
  Serial.print("Position of 'o' starting from index 5: ");
  Serial.println(index3);  // Output: 8
}
void loop() {
  // No code needed here
}

Code Explanation

• The String object message contains the text “Hello, Arduino!”.
• The indexOf(‘A’) function finds the position of the character ‘A’ and returns its index, which is 7.
• The indexOf(“Arduino”) function finds the starting position of the substring “Arduino”, which is also at index 7.
• The indexOf(‘o’, 5) function searches for the character ‘o’ starting from index 5, and it finds ‘o’ at index 8.

Notes

• Returns -1 if not found: If the character or substring is not present in the string, the function returns -1.
• Indexing starts from 0: The first character in the string has an index of 0.
• Optional start position: You can specify the position to start the search with the second parameter, which is useful when you want to skip part of the string or search from a specific point.

Common Problems and Solutions

1. Confusing char[] and String
   Problem: char[] and String are often confused, especially by beginners.
   Solution: Use char[] for fixed-size memory-efficient strings and String for dynamic strings that grow and shrink in size. Example: char greeting[10] = “Hello”;
2. Null Terminator in char[]
   Problem: Not adding the null terminator ‘\0’ when working with char[] can cause unexpected results.
   Solution: Always remember to include a null terminator when manually creating or modifying char[] strings.
   Example: greeting[5] = ‘\0’;
3. Memory Fragmentation in String
   Problem: String objects can cause memory fragmentation on devices with limited memory.
   Solution: Minimize dynamic String manipulation in memory-constrained environments, and prefer char[] when possible.

Chapter Summary

• The char type is used for storing single characters, while unsigned char is used for storing single-byte data (0 to 255).
• The String object is dynamic and useful for working with large text strings, while char[] is more memory-efficient for fixed strings.
• Functions like string.length(), string.concat(), string.toUpperCase(), and string.substring() provide flexibility in handling strings.

FAQ

1. What is the difference between String and char[] in Arduino?
   String is dynamic and allows easy manipulation, while char[] is static and memory-efficient but requires manual memory management.
2. How do I concatenate two strings in Arduino?
   You can use either the string.concat() method or the + operator to concatenate strings.
   Example: greeting.concat(name);
3. What is a null terminator in char[]?
   It is a special character ‘\0’ used to indicate the end of a string in char[]. Without it, the string is not properly terminated, and memory issues may arise.

Simple MCQ Questions and Answers

1. What does the char data type store?
   a) A number
   b) A string
   c) A single character
   d) A boolean
   Answer: c) A single character
2. Which data type should you use for dynamic text in Arduino?
   a) unsigned char
   b) char[]
   c) String
   d) int
   Answer: c) String

What is the ASCII value of ‘A’?
a) 100
b) 65
c) 97
d) 50
Answer: b) 65