How Do You Compare Strings In Arduino Effectively?

Comparing strings in Arduino can be tricky, but it’s essential for many projects. COMPARE.EDU.VN offers comprehensive guides to help you master string comparison techniques, ensuring your code functions as expected. Learn effective methods for string comparison in Arduino and discover why your comparisons might be failing. Understand the nuances of character arrays and String objects and make informed decisions with COMPARE.EDU.VN’s comparison tools.

1. What Are the Common Methods to Compare Strings in Arduino?

Comparing strings is a fundamental operation in Arduino programming, essential for tasks such as validating user input, controlling program flow, and parsing commands. Several methods are available, each with its advantages and disadvantages. Understanding these methods allows you to choose the most appropriate one for your specific application. Here are a few common techniques:

• Using the == Operator: This is the simplest way to compare String objects. It directly compares the contents of the two strings for equality.
• Using the equals() Method: This method, available for String objects, also compares the contents of two strings and returns true if they are identical.
• Using the compareTo() Method: This method, also for String objects, compares two strings lexicographically. It returns 0 if the strings are equal, a negative value if the first string comes before the second, and a positive value if the first string comes after the second.
• Using strcmp() Function: This function is used for comparing C-style strings (character arrays). It’s part of the standard C library and is included in the Arduino environment.

2. How Does the == Operator Work for String Comparison in Arduino?

The == operator is a straightforward way to compare String objects in Arduino. It checks if the content of two strings are identical. Here’s how it works:

1. Syntax: string1 == string2
2. Operation: The operator compares each character in string1 with the corresponding character in string2.
3. Return Value:
   • Returns true if all characters match and the strings have the same length.
   • Returns false otherwise.

Example:

String str1 = "hello";
String str2 = "hello";
String str3 = "world";

if (str1 == str2) {
  Serial.println("str1 and str2 are equal");  // This will be printed
}

if (str1 == str3) {
  Serial.println("str1 and str3 are equal");  // This will not be printed
}

Limitations

• Case Sensitivity: The == operator is case-sensitive. For example, "Hello" and "hello" are considered different.
• String Objects Only: This operator works only with String objects, not with C-style character arrays.

Best Practices

• Use == when comparing String objects for exact equality.
• Be mindful of case sensitivity. If case-insensitive comparison is needed, convert both strings to the same case before comparison.

3. What is the equals() Method for String Objects in Arduino?

The equals() method is another way to compare String objects in Arduino. It’s similar to the == operator but is explicitly a method of the String class.

1. Syntax: string1.equals(string2)
2. Operation: The equals() method compares each character in string1 with the corresponding character in string2.
3. Return Value:
   • Returns true if all characters match and the strings have the same length.
   • Returns false otherwise.

Example:

String str1 = "hello";
String str2 = "hello";
String str3 = "world";

if (str1.equals(str2)) {
  Serial.println("str1 and str2 are equal");  // This will be printed
}

if (str1.equals(str3)) {
  Serial.println("str1 and str3 are equal");  // This will not be printed
}

Advantages

• Clarity: Using equals() can make the code more readable, as it explicitly indicates a string comparison.
• Consistency: It’s consistent with how string comparison is done in many other programming languages.

Limitations

• Case Sensitivity: The equals() method is case-sensitive.
• String Objects Only: This method works only with String objects, not with C-style character arrays.

Best Practices

• Use equals() when comparing String objects for exact equality.
• For case-insensitive comparisons, convert both strings to the same case before using equals().

4. How Does the compareTo() Method Function in Arduino String Comparisons?

The compareTo() method provides a more detailed comparison between two String objects. It compares the strings lexicographically, meaning it considers the Unicode value of each character.

1. Syntax: string1.compareTo(string2)
2. Operation: The compareTo() method compares string1 to string2 character by character.
3. Return Value:
   • Returns 0 if the strings are equal.
   • Returns a negative value if string1 is lexicographically less than string2.
   • Returns a positive value if string1 is lexicographically greater than string2.

Example:

String str1 = "apple";
String str2 = "banana";
String str3 = "apple";

int result1 = str1.compareTo(str2);
int result2 = str1.compareTo(str3);

Serial.print("Result 1: ");
Serial.println(result1);  // Output: Result 1: -1

Serial.print("Result 2: ");
Serial.println(result2);  // Output: Result 2: 0

if (result1 < 0) {
  Serial.println("str1 comes before str2");  // This will be printed
}

if (result2 == 0) {
  Serial.println("str1 and str3 are equal");  // This will be printed
}

Use Cases

• Sorting: Useful for sorting strings in alphabetical order.
• Detailed Comparison: Provides more information than simple equality checks.

Limitations

• Case Sensitivity: The compareTo() method is case-sensitive.
• String Objects Only: This method works only with String objects.

Best Practices

• Use compareTo() when you need to determine the relative order of two strings.
• Be aware of case sensitivity. Convert strings to the same case if needed.

5. What is the strcmp() Function for Comparing C-Style Strings in Arduino?

The strcmp() function is used for comparing C-style strings (character arrays) in Arduino. It’s part of the standard C library and is included in the Arduino environment.

1. Syntax: strcmp(string1, string2)
2. Operation: The strcmp() function compares string1 to string2 character by character until it finds a difference or reaches the end of the strings.
3. Return Value:
   • Returns 0 if the strings are equal.
   • Returns a negative value if string1 is lexicographically less than string2.
   • Returns a positive value if string1 is lexicographically greater than string2.

Example:

char str1[] = "hello";
char str2[] = "hello";
char str3[] = "world";

int result1 = strcmp(str1, str2);
int result2 = strcmp(str1, str3);

Serial.print("Result 1: ");
Serial.println(result1);  // Output: Result 1: 0

Serial.print("Result 2: ");
Serial.println(result2);  // Output: Result 2: -15

if (result1 == 0) {
  Serial.println("str1 and str2 are equal");  // This will be printed
}

if (result2 < 0) {
  Serial.println("str1 comes before str3");  // This will be printed
}

Advantages

• Efficiency: strcmp() is generally faster and uses less memory than String object methods.
• Compatibility: Works with C-style strings, which are common in C/C++ programming.

Limitations

• Case Sensitivity: The strcmp() function is case-sensitive.
• Null Termination: C-style strings must be null-terminated.

Best Practices

• Use strcmp() when working with C-style strings.
• Ensure that your character arrays are properly null-terminated.
• Consider using strncmp() to compare a specific number of characters.

6. Why is Case Sensitivity Important in Arduino String Comparisons?

Case sensitivity is a critical factor in Arduino string comparisons because the comparison methods differentiate between uppercase and lowercase letters. This means that "Hello" and "hello" are treated as different strings.

Impact on Comparisons:

• Equality Checks: Using == or equals() will return false if the strings differ only in case.
• Lexicographical Comparisons: compareTo() and strcmp() will consider the ASCII/Unicode values of the characters, leading to different results based on case.

Example:

String str1 = "Hello";
String str2 = "hello";

if (str1 == str2) {
  Serial.println("Strings are equal");  // This will not be printed
} else {
  Serial.println("Strings are not equal");  // This will be printed
}

int result = str1.compareTo(str2);
Serial.print("Comparison result: ");
Serial.println(result);  // Output: Comparison result: -32

How to Perform Case-Insensitive Comparisons

To perform case-insensitive comparisons, convert both strings to the same case (either uppercase or lowercase) before comparing them.

Using toLowerCase() and toUpperCase():

String str1 = "Hello";
String str2 = "hello";

String lowerStr1 = str1.toLowerCase();
String lowerStr2 = str2.toLowerCase();

if (lowerStr1 == lowerStr2) {
  Serial.println("Strings are equal (case-insensitive)");  // This will be printed
}

Using Character Array Manipulation:

For C-style strings, you can iterate through the characters and convert them individually.

#include <ctype.h>

void toLower(char *str) {
  for (int i = 0; str[i]; i++) {
    str[i] = tolower(str[i]);
  }
}

char str1[] = "Hello";
char str2[] = "hello";

toLower(str1);
toLower(str2);

if (strcmp(str1, str2) == 0) {
  Serial.println("Strings are equal (case-insensitive)");  // This will be printed
}

Best Practices

• Always consider case sensitivity when comparing strings.
• Use toLowerCase() or toUpperCase() methods for case-insensitive comparisons with String objects.
• Use character array manipulation and tolower() function for case-insensitive comparisons with C-style strings.

7. How Do You Compare Substrings in Arduino?

Comparing substrings involves checking if a portion of one string matches a portion of another. Arduino offers several ways to achieve this.

Using substring() Method

The substring() method of the String class extracts a portion of a string. You can then compare this substring with another string.

1. Syntax: string.substring(startIndex, endIndex)
2. Operation: Extracts the substring starting at startIndex and ending before endIndex.
3. Comparison: Compare the extracted substring with another string using ==, equals(), or compareTo().

Example:

String str = "This is a test";
String subStr = str.substring(0, 4);  // Extracts "This"

if (subStr == "This") {
  Serial.println("Substring matches");  // This will be printed
}

Using startsWith() and endsWith() Methods

The startsWith() and endsWith() methods check if a string starts or ends with a specific substring.

1. Syntax:
   • string.startsWith(prefix)
   • string.endsWith(suffix)
2. Operation: Checks if the string starts with prefix or ends with suffix.
3. Return Value: Returns true if the condition is met, false otherwise.

Example:

String str = "This is a test";

if (str.startsWith("This")) {
  Serial.println("String starts with 'This'");  // This will be printed
}

if (str.endsWith("test")) {
  Serial.println("String ends with 'test'");  // This will be printed
}

Using strstr() Function for C-Style Strings

The strstr() function is used to find the first occurrence of a substring within a C-style string.

1. Syntax: strstr(string, substring)
2. Operation: Locates the first occurrence of substring in string.
3. Return Value:
   • Returns a pointer to the beginning of the located substring, or NULL if the substring is not found.

Example:

char str[] = "This is a test";
char subStr[] = "is";

char *result = strstr(str, subStr);

if (result != NULL) {
  Serial.println("Substring found");  // This will be printed
}

Best Practices

• Use substring() when you need to extract and compare specific portions of a string.
• Use startsWith() and endsWith() for simple prefix and suffix checks.
• Use strstr() for finding substrings within C-style strings.

8. How Can You Ignore Leading and Trailing Whitespace During String Comparison in Arduino?

Leading and trailing whitespace can cause string comparisons to fail even if the visible content is the same. Removing this whitespace before comparison is crucial for accurate results.

Using trim() Method

The String class provides a trim() method that removes leading and trailing whitespace from a string.

1. Syntax: string.trim()
2. Operation: Removes whitespace characters (spaces, tabs, newlines, etc.) from the beginning and end of the string.

Example:

String str1 = "  hello  ";
String str2 = "hello";

str1.trim();

if (str1 == str2) {
  Serial.println("Strings are equal after trimming");  // This will be printed
}

Manual Trimming for C-Style Strings

For C-style strings, you can manually remove whitespace by iterating through the string.

#include <ctype.h>

void trim(char *str) {
  int start = 0;
  int end = strlen(str) - 1;

  // Remove leading whitespace
  while (isspace((unsigned char)str[start])) {
    start++;
  }

  // Remove trailing whitespace
  while (end > start && isspace((unsigned char)str[end])) {
    end--;
  }

  // Shift the string to the beginning
  for (int i = 0; i <= end - start; i++) {
    str[i] = str[start + i];
  }

  // Null-terminate the trimmed string
  str[end - start + 1] = '';
}

char str1[] = "  hello  ";
char str2[] = "hello";

trim(str1);

if (strcmp(str1, str2) == 0) {
  Serial.println("Strings are equal after trimming");  // This will be printed
}

Best Practices

• Always trim strings before comparison if whitespace might be present.
• Use the trim() method for String objects.
• Implement manual trimming for C-style strings, ensuring proper null termination.

9. How to Handle Null Strings and Empty Strings in Arduino Comparisons?

Handling null and empty strings is essential to prevent unexpected behavior and errors in Arduino programs.

Checking for Null Strings

In Arduino, String objects cannot be null. However, C-style strings can be null pointers. Always check for null pointers before attempting to use them.

char *str = NULL;

if (str == NULL) {
  Serial.println("String is NULL");  // This will be printed
} else {
  // Avoid dereferencing a null pointer
  Serial.println("String is not NULL");
}

Checking for Empty Strings

An empty string is a string with no characters (but is properly initialized).

For String Objects:

String str = "";

if (str.length() == 0) {
  Serial.println("String is empty");  // This will be printed
}

For C-Style Strings:

char str[] = "";

if (str[0] == '') {
  Serial.println("String is empty");  // This will be printed
}

Comparing with Empty Strings

When comparing strings, check if either string is empty before proceeding with the comparison.

For String Objects:

String str1 = "";
String str2 = "hello";

if (str1.length() == 0 || str2.length() == 0) {
  Serial.println("One of the strings is empty");  // This will be printed
}

For C-Style Strings:

char str1[] = "";
char str2[] = "hello";

if (str1[0] == '' || str2[0] == '') {
  Serial.println("One of the strings is empty");  // This will be printed
}

Best Practices

• Always check for null pointers before using C-style strings.
• Check for empty strings using length() == 0 for String objects and str[0] == '' for C-style strings.
• Handle null and empty strings gracefully in your comparison logic.

10. How Do You Convert Numbers to Strings and Compare Them in Arduino?

Sometimes, you need to compare numbers that are stored as strings or convert numbers to strings for comparison. Arduino provides methods for these conversions.

Converting Numbers to String Objects

You can use the String() constructor to convert numbers to String objects.

int num = 123;
String str = String(num);

if (str == "123") {
  Serial.println("Number converted to string and compared successfully");  // This will be printed
}

Converting Numbers to C-Style Strings

Use the sprintf() function to convert numbers to C-style strings.

char str[10];
int num = 123;

sprintf(str, "%d", num);

if (strcmp(str, "123") == 0) {
  Serial.println("Number converted to string and compared successfully");  // This will be printed
}

Comparing Numbers Stored as Strings

If you need to compare numbers stored as strings numerically, convert them back to numbers before comparing.

Using toInt() for String Objects:

String str1 = "123";
String str2 = "456";

int num1 = str1.toInt();
int num2 = str2.toInt();

if (num1 < num2) {
  Serial.println("str1 is less than str2");  // This will be printed
}

Using atoi() for C-Style Strings:

char str1[] = "123";
char str2[] = "456";

int num1 = atoi(str1);
int num2 = atoi(str2);

if (num1 < num2) {
  Serial.println("str1 is less than str2");  // This will be printed
}

Best Practices

• Use String() constructor or sprintf() to convert numbers to strings.
• Use toInt() or atoi() to convert strings back to numbers for numerical comparisons.
• Ensure that the string contains a valid number before attempting conversion to avoid errors.

11. What Are the Differences Between Using String Objects and C-Style Strings in Arduino?

Arduino supports two types of strings: String objects and C-style strings (character arrays). Understanding their differences is crucial for efficient and effective programming.

String Objects

• Dynamic Memory Allocation: String objects use dynamic memory allocation, which means they can grow or shrink as needed.
• Ease of Use: They provide methods for string manipulation, making them easier to use.
• Memory Overhead: Dynamic memory allocation can lead to memory fragmentation and potential crashes if not managed carefully.

Example:

String str = "hello";
str += " world";  // Appending to a String object
Serial.println(str);  // Output: hello world

C-Style Strings (Character Arrays)

• Static Memory Allocation: C-style strings use static memory allocation, meaning their size is fixed at compile time.
• Efficiency: They are generally more efficient in terms of memory usage and processing speed.
• Manual Management: Require manual memory management and null termination.

Example:

char str[20] = "hello";
strcat(str, " world");  // Appending to a C-style string
Serial.println(str);  // Output: hello world

Comparison Table

Feature	String Objects	C-Style Strings (char arrays)
Memory Allocation	Dynamic	Static
Memory Management	Automatic	Manual
Ease of Use	Easier (methods available)	More complex (manual)
Memory Efficiency	Less efficient	More efficient
Risk of Fragmentation	Higher	Lower
Null Termination	Implicit	Explicit

Best Practices

• Use String objects for ease of use and when dynamic string manipulation is required.
• Use C-style strings for memory efficiency and when working with low-memory devices.
• Avoid excessive use of String objects in memory-constrained environments.

12. How Can You Optimize String Comparisons for Performance in Arduino?

Optimizing string comparisons is essential for improving the performance of Arduino programs, especially in applications that involve frequent string operations.

Use C-Style Strings When Possible

C-style strings are generally more efficient than String objects due to their static memory allocation.

char str1[] = "hello";
char str2[] = "world";

if (strcmp(str1, str2) == 0) {
  Serial.println("Strings are equal");
}

Minimize String Object Usage

Excessive use of String objects can lead to memory fragmentation and performance issues. Use them judiciously and consider alternatives when possible.

Use strncmp() for Partial Comparisons

If you only need to compare a specific number of characters, use strncmp() instead of strcmp().

char str1[] = "hello world";
char str2[] = "hello arduino";

if (strncmp(str1, str2, 5) == 0) {
  Serial.println("First 5 characters are equal");
}

Convert to Lower or Upper Case Before Comparison

If you need to perform case-insensitive comparisons, convert the strings to the same case before comparing. This avoids multiple comparisons.

String str1 = "Hello";
String str2 = "hello";

String lowerStr1 = str1.toLowerCase();
String lowerStr2 = str2.toLowerCase();

if (lowerStr1 == lowerStr2) {
  Serial.println("Strings are equal (case-insensitive)");
}

Avoid Repeated String Concatenation

Repeated string concatenation using String objects can be inefficient. Use String.concat() or C-style string manipulation instead.

String str = "hello";
str.concat(" world");  // More efficient than str += " world";

Best Practices

• Prioritize C-style strings for performance-critical applications.
• Minimize the use of String objects.
• Use strncmp() for partial comparisons.
• Convert strings to the same case before case-insensitive comparisons.
• Avoid repeated string concatenation with String objects.

13. What Are Common Mistakes to Avoid When Comparing Strings in Arduino?

Avoiding common mistakes is crucial for ensuring accurate and reliable string comparisons in Arduino.

Incorrectly Comparing String Objects and C-Style Strings

Ensure that you are using the correct comparison methods for the string type you are working with.

• Use ==, equals(), or compareTo() for String objects.
• Use strcmp() for C-style strings.

Incorrect:

String str1 = "hello";
char str2[] = "hello";

if (str1 == str2) {  // Incorrect: comparing String object with char array using ==
  Serial.println("Strings are equal");
}

Correct:

String str1 = "hello";
char str2[] = "hello";

if (str1.equals(str2)) {  // Correct: using equals() method
  Serial.println("Strings are equal");
}

if (strcmp(str1.c_str(), str2) == 0) {  // Correct: converting String to C-style string
  Serial.println("Strings are equal");
}

Ignoring Case Sensitivity

Remember that string comparisons are case-sensitive by default. Use toLowerCase() or toUpperCase() for case-insensitive comparisons.

Incorrect:

String str1 = "Hello";
String str2 = "hello";

if (str1 == str2) {  // Incorrect: case-sensitive comparison
  Serial.println("Strings are equal");
}

Correct:

String str1 = "Hello";
String str2 = "hello";

if (str1.toLowerCase() == str2.toLowerCase()) {  // Correct: case-insensitive comparison
  Serial.println("Strings are equal");
}

Forgetting Null Termination for C-Style Strings

C-style strings must be null-terminated. Ensure that your character arrays have a null terminator () at the end.

Incorrect:

char str[5] = {'h', 'e', 'l', 'l', 'o'};  // Missing null terminator
if (strcmp(str, "hello") == 0) {
  Serial.println("Strings are equal");  // May not work correctly
}

Correct:

char str[6] = "hello";  // Null terminator is automatically added
if (strcmp(str, "hello") == 0) {
  Serial.println("Strings are equal");  // Works correctly
}

Not Handling Leading and Trailing Whitespace

Whitespace can cause comparisons to fail. Use trim() to remove leading and trailing whitespace before comparing.

Incorrect:

String str1 = "  hello";
String str2 = "hello";

if (str1 == str2) {  // Incorrect: whitespace not handled
  Serial.println("Strings are equal");
}

Correct:

String str1 = "  hello";
String str2 = "hello";

str1.trim();
if (str1 == str2) {  // Correct: whitespace handled
  Serial.println("Strings are equal");
}

Best Practices

• Use the correct comparison methods for the string type.
• Be aware of case sensitivity and use toLowerCase() or toUpperCase() when needed.
• Ensure null termination for C-style strings.
• Handle leading and trailing whitespace using trim().

14. How Do External Libraries Assist in Complex String Comparisons in Arduino?

While Arduino’s built-in functions cover basic string comparisons, external libraries offer more advanced capabilities for complex scenarios.

Available Libraries

1. String functions:
   • indexOf(): Locates the first occurrence of a substring within a string.
   • lastIndexOf(): Locates the last occurrence of a substring within a string.
   • replace(): Replaces all occurrences of a substring with another string.
2. String conversion:
   • toCharArray(): Copies the contents of a String object to a C-style character array.

Examples of Complex Comparisons

1. Regular Expressions:

   • Libraries like regexpp provide regular expression matching, allowing complex pattern-based comparisons.

2. Fuzzy String Matching:

   • Libraries like Fuzzy String Matching offer algorithms like Levenshtein distance for approximate string matching.

3. Advanced Parsing:

   • Libraries like arduino-cookbook support parsing complex string formats.

Best Practices

• Use external libraries when built-in functions are insufficient for complex comparisons.
• Evaluate library compatibility and resource usage.
• Understand the algorithms behind fuzzy matching libraries.

15. How Does Arduino Handle Unicode and Special Characters in String Comparisons?

Arduino’s string handling capabilities extend to Unicode and special characters, but there are considerations to keep in mind.

Unicode Support

• Limited Support: The Arduino environment has limited native support for Unicode.
• UTF-8 Encoding: Use UTF-8 encoding for Unicode characters.
• Character Representation: Special characters can be represented using escape sequences or their Unicode code points.

String Comparison with Unicode

• Character Encoding: Ensure consistent character encoding when comparing strings with Unicode characters.
• Case Sensitivity: Comparisons remain case-sensitive unless explicitly handled.
• Special Characters: Account for special characters like accented letters, symbols, or emojis.

Best Practices

• Use UTF-8 encoding for Unicode characters.
• Understand character representation and encoding.
• Handle case sensitivity and special characters appropriately.
• Consider external libraries for advanced Unicode support.

FAQ: Comparing Strings in Arduino

1. Why is my string comparison not working in Arduino?
String comparisons in Arduino might fail due to case sensitivity, whitespace, or using the wrong comparison method. Ensure you use the appropriate method (==, equals(), strcmp()) and handle case and whitespace correctly.

2. How do I perform a case-insensitive string comparison in Arduino?
To perform a case-insensitive string comparison, convert both strings to either lowercase or uppercase before comparing them using the toLowerCase() or toUpperCase() methods.

3. Can I use == to compare C-style strings in Arduino?
No, you cannot use == to compare C-style strings. Use the strcmp() function instead. The == operator compares memory addresses, not the content of the strings.

4. How do I compare a substring within a string in Arduino?
You can use the substring() method to extract a portion of a string and then compare it with another string. Alternatively, use startsWith() or endsWith() to check prefixes and suffixes.

5. How do I remove leading and trailing whitespace from a string in Arduino?
Use the trim() method to remove leading and trailing whitespace from String objects. For C-style strings, you’ll need to implement manual trimming.

6. What is the difference between String objects and C-style strings in Arduino?
String objects use dynamic memory allocation and provide methods for string manipulation, while C-style strings use static memory allocation and require manual memory management. C-style strings are generally more efficient but require more careful handling.

7. How do I convert a number to a string in Arduino for comparison?
You can use the String() constructor to convert a number to a String object or the sprintf() function to convert a number to a C-style string.

8. How do I handle null or empty strings in Arduino comparisons?
Check for null pointers before using C-style strings and check for empty strings using length() == 0 for String objects and str[0] == '' for C-style strings.

9. Can I use regular expressions for string comparisons in Arduino?
Yes, you can use external libraries like regexpp to perform regular expression matching for complex pattern-based comparisons.

10. How do I optimize string comparisons for performance in Arduino?
Use C-style strings when possible, minimize the use of String objects, use strncmp() for partial comparisons, and convert strings to the same case before case-insensitive comparisons.

Conclusion

Mastering string comparison in Arduino involves understanding the available methods, their nuances, and how to avoid common pitfalls. Whether you’re using String objects or C-style strings, the right approach can ensure accurate and efficient code. For more detailed comparisons, reviews, and guidance, visit COMPARE.EDU.VN, your trusted resource for making informed decisions. Explore comprehensive resources at COMPARE.EDU.VN to make confident choices.

Ready to make smarter comparisons? Visit COMPARE.EDU.VN today and unlock a world of information to help you choose the best options for your needs.

Address: 333 Comparison Plaza, Choice City, CA 90210, United States

WhatsApp: +1 (626) 555-9090

Website: compare.edu.vn

Alt text: An Arduino board connected to a computer, highlighting the process of string comparison in the Arduino IDE.