lcd display c code quotation

Connecting an LCD display to your Raspberry Pi is sure to take any project up a notch. They’re great for displaying sensor readings, songs or internet radio stations, and stuff from the web like tweets and stock quotes. Whatever you choose to display, LCDs are a simple and inexpensive way to do it.

In this tutorial, I’ll show you two different ways to connect an LCD to the Raspberry Pi with the GPIO pins. The first way I’ll show you is in 8 bit mode, which uses 10 GPIO pins. Then I’ll show you how to connect it in 4 bit mode, and that uses only 6 pins. After we get the LCD hooked up I’ll show you how to program it with C, using Gordon Henderson’s WiringPi LCD library.

I’ll show you how to print text to the display, clear the screen, position the text, and control the cursor. You’ll also see how to scroll text, create custom characters, print data from a sensor, and print the date, time and IP address of your Pi.

BONUS: I made a quick start guide for this tutorial that you can download and go back to later if you can’t set this up right now. It covers all of the steps, diagrams, and code you need to get started.

There’s another way to connect your LCD that uses only two wires, called I2C. To see how to do that, check out our tutorial How to Set Up an I2C LCD on the Raspberry Pi.

Most people probably want to connect their LCD in 4 bit mode since it uses less wires. But in case you’re interested, I’ll show you how to connect it in 8 bit mode as well.

In 8 bit mode, each command or character is sent to the LCD as a single byte (8 bits) of data. The byte travels in parallel over 8 data wires, with each bit travelling through it’s own wire. 8 bit mode has twice the bandwidth as 4 bit mode, which in theory translates to higher data transfer speed. The main downside to 8 bit mode is that it uses up a lot of GPIO pins.

In 4 bit mode, each byte of data is sent to the LCD in two sets of 4 bits, one after the other, in what are known as the upper bits and lower bits. Although 8 bit mode transfers data about twice as fast as 4 bit mode, it takes a longer time for the LCD driver to process each byte than it takes to transmit the byte. So in reality, there isn’t really a noticeable difference in speed between 4 bit mode and 8 bit mode.

If you’ve never worked with C programs on the Raspberry Pi, you may want to read our article How to Write and Run a C Program on the Raspberry Pi first. It will explain how to write, compile, and run C programs.

WiringPi is a C module that makes it easy to program the LCD. If you already have WiringPi installed on your Pi, you can skip this section. If not, follow the steps below to install it:

WiringPi has it’s own pin numbering system that’s different from the Broadcom (BCM) and RPi physical (BOARD) pin numbering systems. All of the programs below use the WiringPi pin numbers.

To use different pins to connect the LCD, change the pin numbers defined in lines 5 to 14. You’ll need to convert the WiringPi pin numbers to the physical pin numbers of the Raspberry Pi. See here for a diagram you can use to convert between the different numbering systems.

To use the LCD in 4 bit mode, we need to set the bit mode number to 4 in the initialization function (line 20 below). The following code prints “Hello, world!” to the screen in 4 bit mode:

By default, text is printed to the screen at the top row, second column. To change the position, use lcdPosition(lcd, COLUMN, ROW). On a 16×2 LCD, the rows are numbered from 0 to 1, and the columns are numbered from 0 to 15.

The function lcdClear(lcd) clears the screen and sets the cursor position at the top row, first column. This program prints “This is how you” for two seconds, clears the screen, then prints “clear the screen” for another two seconds:

Notice how the first string is printed to the top row, second column (the default position). Then after clearing the screen, the second string is printed to the top row, first column.

Each LCD character is a 5×8 array of pixels. You can create any pattern you want and display it on the LCD as a custom character. Up to 8 custom characters can be stored in the LCD memory at a time. This website has a nice visual way to generate the bit array used to define custom characters.

To print a single custom character, first define the character. For an example of this see lines 12 to 19 below. Then use the function lcdCharDef(lcd, 2, omega) to store the character in the LCD’s memory. The number 2 in this example is one of the 8 locations in the LCD’s character memory. The 8 locations are numbered 0-7. Then, print the character to the display with lcdPutchar(lcd, 2), where the number 2 is the character stored in memory location 2.

Here’s an example of using multiple custom characters that prints the Greek letters omega, pi, and mu, plus thermometer and water drop symbols for temperature and humidity:

As an example to show you how to display readings from a sensor, this program prints temperature and humidity readings to the LCD using a DHT11 temperature and humidity sensor. To see how to set up the DHT11 on the Raspberry Pi, see our article How to Set Up the DHT11 Humidity Sensor on the Raspberry Pi.

Hopefully this helped you get your LCD up and running on your Raspberry Pi. The programs above are just basic examples, so try combining them to create interesting effects and animations.

If you have any problems or questions about installing the LCD or programming it, just leave a comment below. And don’t forget to subscribe to get an email when we publish new articles. Talk to you next time!

OK, this is the sketch that I used to try out user-defined characters on a four-row, 20 character LCD. If you have a two-row LCD, you"ll have to change the calls to "drawbar" in the main loop. You"ll need a potentiometer with the track connected to 0V and 5V, and the wiper connected to analog in 0. Turn (or slide) the pot to see the bar extend across the LCD. The crucial command to the LCD is 0x40, which is used to position the "cursor" in the CGRAM, which is where the user-defined characters are stored. A call to "home" is required after defining the characters, to put the cursor back into the main display memory. All this is documented in the HD44780 data sheet.

The Serial Monitor is a convenient way to view data from an Arduino, but what if you want to make your project portable and view sensor values without access to a computer? Liquid crystal displays (LCDs) are excellent for displaying a string of words or sensor data.

This guide will help you in getting your 16×2 character LCD up and running, as well as other character LCDs (such as 16×4, 16×1, 20×4, etc.) that use Hitachi’s LCD controller chip, the HD44780.

When activated by an electric current, these liquid crystals become opaque, blocking the backlight that is located behind the screen. As a result, that area will be darker than the rest. By activating the liquid crystal layer in specific pixels, characters can be generated.

As the name suggests, these LCDs are ideal for displaying only characters. A 16×2 character LCD, for example, can display 32 ASCII characters across two rows.

If you look closely, you can see tiny rectangles for each character on the screen as well as the pixels that make up a character. Each of these rectangles is a grid of 5×8 pixels.

Character LCDs are available in a variety of sizes and colors, including 16×1, 16×4, 20×4, white text on a blue background, black text on a green background, and many more.

One advantage of using any of these displays in your project is that they are “swappable,” meaning that you can easily replace them with another LCD of a different size or color. Your code will need to be tweaked slightly, but the wiring will remain the same!

Before we get into the hookup and example code, let’s check out the pinout. A standard character LCD has 16 pins (except for an RGB LCD, which has 18 pins).

Vo (LCD Contrast) pin controls the contrast of the LCD. Using a simple voltage divider network and a potentiometer, we can make precise contrast adjustments.

RS (Register Select) pin is used to separate the commands (such as setting the cursor to a specific location, clearing the screen, etc.) from the data. The RS pin is set to LOW when sending commands to the LCD and HIGH when sending data.

R/W (Read/Write) pin allows you to read data from or write data to the LCD. Since the LCD is only used as an output device, this pin is typically held low. This forces the LCD into WRITE mode.

E (Enable) pin is used to enable the display. When this pin is set to LOW, the LCD ignores activity on the R/W, RS, and data bus lines; when it is set to HIGH, the LCD processes the incoming data.

D0-D7 (Data Bus) pins carry the 8 bit data we send to the display. To see an uppercase ‘A’ character on the display, for example, we set these pins to 0100 0001 (as per the ASCII table).

The LCD has two separate power connections: one for the LCD (pins 1 and 2) and one for the LCD backlight (pins 15 and 16). Connect LCD pins 1 and 16 to GND and 2 and 15 to 5V.

Depending on the manufacturer, some LCDs include a current-limiting resistor for the backlight. It is located on the back of the LCD, close to pin 15. If your LCD does not contain this resistor or if you are unsure whether it does, you must add one between 5V and pin 15. It should be safe to use a 220 ohm resistor, although a value this high may make the backlight slightly dim. For better results, check the datasheet for the maximum backlight current and choose an appropriate resistor value.

Let’s connect a potentiometer to the display. This is necessary to fine-tune the contrast of the display for best visibility. Connect one side of the 10K potentiometer to 5V and the other to Ground, and connect the middle of the pot (wiper) to LCD pin 3.

That’s all. Now, turn on the Arduino. You will see the backlight light up. As you turn the potentiometer knob, you will see the first row of rectangles appear. If you have made it this far, Congratulations! Your LCD is functioning properly.

We know that data is sent to the LCD via eight data pins. However, HD44780-based LCDs are designed so that we can communicate with them using only four data pins (in 4-bit mode) rather than eight (in 8-bit mode). This helps us save 4 I/O pins!

8-bit mode is significantly faster than 4-bit mode. This is because in 8-bit mode, data is written in a single operation, whereas in 4-bit mode, a byte is split into two nibbles and two write operations are performed.

Therefore, 4-bit mode is commonly used to save I/O pins. 8-bit mode, on the other hand, is best suited when speed is a priority in the application and at least 10 I/O pins are available.

The sketch begins by including the LiquidCrystal library. This library comes with the Arduino IDE and allows you to control Hitachi HD44780 driver-based LCD displays.

Next, an object of the LiquidCrystal class is created by passing as parameters the pin numbers to which the LCD’s RS, EN, and four data pins are connected.

In the setup, two functions are called. The first function is begin(). It is used to initialize the interface to the LCD screen and to specify the dimensions (columns and rows) of the display. If you’re using a 16×2 character LCD, you should pass 16 and 2; if you’re using a 20×4 LCD, you should pass 20 and 4.

In the loop, the print() function is used to print “Hello world!” to the LCD. Please remember to use quotation marks " " around the text. There is no need for quotation marks when printing numbers or variables.

The function setCursor() is then called to move the cursor to the second row. The cursor position specifies where you want the new text to appear on the LCD. It is assumed that the upper left corner is col=0 and row=0.

There are many useful functions you can use with LiquidCrystal Object. Some of them are listed below:lcd.home() function positions the cursor in the upper-left of the LCD without clearing the display.

lcd.scrollDisplayRight() function scrolls the contents of the display one space to the right. If you want the text to scroll continuously, you have to use this function inside a for loop.

lcd.scrollDisplayLeft() function scrolls the contents of the display one space to the left. Similar to the above function, use this inside a for loop for continuous scrolling.

lcd.display() function turns on the LCD display, after it’s been turned off with noDisplay(). This will restore the text (and cursor) that was on the display.

If you find the default font uninteresting, you can create your own custom characters (glyphs) and symbols. They come in handy when you need to display a character that isn’t in the standard ASCII character set.

As previously discussed in this tutorial, a character is made up of a 5×8 pixel matrix; therefore, you must define your custom character within this matrix. You can define a character by using the createChar() function.

To use createChar(), you must first create an 8-byte array. Each byte in the array corresponds to a row in a 5×8 matrix. In a byte, the digits 0 and 1 indicate which pixels in a row should be ON and which should be OFF.

CGROM is non-volatile memory that retains data even when the power is removed, whereas CGRAM is volatile memory that loses data when the power is removed.

The CGROM stores the font that appears on a character LCD. When you instruct a character LCD to display the letter ‘A’, it needs to know which dots to turn on so that we see an ‘A’. This data is stored in the CGROM.

CGRAM is an additional memory for storing user-defined characters. This RAM is limited to 64 bytes. Therefore, for a 5×8 pixel LCD, only 8 user-defined characters can be stored in CGRAM, whereas for a 5×10 pixel LCD, only 4 can be stored.

Creating custom characters has never been easier! We’ve developed a small application called Custom Character Generator. Can you see the blue grid below? You can click on any pixel to set or clear that pixel. And as you click, the code for the character is generated next to the grid. This code can be used directly in your Arduino sketch.

There’s no limit to what you can create. The only limitation is that the LiquidCrystal library only supports eight custom characters. But don’t be sad, look at the bright side; at least we have eight characters.

After including the library and creating the LCD object, custom character arrays are defined. The array consists of 8 bytes, with each byte representing a row in a 5×8 matrix.

This sketch contains eight custom-characters. Take, for example, the Heart[8] array. You can see that the bits (0s and 1s) are forming the shape of a heart. 0 turns the pixel off, and 1 turns it on.

In the setup, we use the createChar() function to create a custom character. This function accepts two parameters: a number between 0 and 7 to reserve one of the eight supported custom characters, and the name of the array.

From Figure 3 above we can see that the DDRAM controller should have a memory map of 104 bytes (00H to 67H = 68H = 104D), but the location that can be used is only 80 bytes 00H-27H (40 bytes) and 40H-67H (40 bytes); Note that the 28H-3FH address (24 location) is not visible.

LCD connected to this controller will adjust itself to the memory map of this DDRAM controller; each location on the LCD will take 1 DDRAM address on the controller. Because we use 2 × 16 type LCD, the first line of the LCD will take the location of the 00H-0FH addresses and the second line will take the 40H-4FH addresses of the controller DDRAM; so neither the addresses of the 10H-27H on the first line or the addresses of the 50H-67H on the second line on DDRAM is used.

To be able to display a character on the first line of the LCD, we must provide written instructions (80h + DDRAM address where our character is to be displayed on the first line) in the Instruction Register-IR and then followed by writing the ASCII code of the character or address of the character stored on the CGROM or CGRAM on the LCD controller data register, as well as to display characters in the second row we must provide written instructions (C0H + DDRAM address where our character to be displayed on the second line) in the Instructions Register-IR and then followed by writing the ASCII code or address of the character on CGROM or CGRAM on the LCD controller data register.

As mentioned above, to display a character (ASCII) you want to show on the LCD, you need to send the ASCII code to the LCD controller data register-DR. For characters from CGROM and CGRAM we only need to send the address of the character where the character is stored; unlike the character of the ASCII code, we must write the ASCII code of the character we want to display on the LCD controller data register to display it. For special characters stored on CGRAM, one must first save the special character at the CGRAM address (prepared 64 addresses, namely addresses 0–63); A special character with a size of 5 × 8 (5 columns × 8 lines) requires eight consecutive addresses to store it, so the total special characters that can be saved or stored on the CGRAM addresses are only eight (8) characters. To be able to save a special character at the first CGRAM address we must send or write 40H instruction to the Instruction Register-IR followed by writing eight consecutive bytes of the data in the Data Register-DR to save the pattern/image of a special character that you want to display on the LCD [9, 10].

We can easily connect this LCD module (LCD + controller) with MCS51, and we do not need any additional electronic equipment as the interface between MCS51 and it; This is because this LCD works with the TTL logic level voltage—Transistor-Transistor Logic.

The voltage source of this display is +5 V connected to Pin 2 (VCC) and GND power supply connected to Pin 1 (VSS) and Pin 16 (GND); Pin 1 (VSS) and Pin 16 (GND) are combined together and connected to the GND of the power supply.

Pins 7–14 (8 Pins) of the display function as a channel to transmit either data or instruction with a channel width of 1 byte (D0-D7) between the display and MCS51. In Figure 6, it can be seen that each Pin connected to the data bus (D0-D7) of MCS51 in this case P0 (80h); P0.0-P0.7 MCS-51 connected to D0-D7 of the LCD.

Pins 4–6 are used to control the performance of the display. Pin 4 (Register Select-RS) is in charge of selecting one of the 2 display registers. If RS is given logic 0 then the selected register is the Instruction Register-IR, otherwise, if RS is given logic 1 then the selected register is the Data Register-DR. The implication of this selection is the meaning of the signal sent down through the data bus (D0-D7), if RS = 0, then the signal sent from the MCS-51 to the LCD is an instruction; usually used to configure the LCD, otherwise if RS = 1 then the data sent from the MCS-51 to the LCD (D0-D7) is the data (object or character) you want to display on the LCD. From Figure 6 Pin 4 (RS) is connected to Pin 16 (P3.6/W¯) of MCS-51 with the address (B6H).

Pin 5 (R/W¯)) of the LCD does not appear in Figure 6 is used for read/write operations. If Pin 5 is given logic 1, the operation is a read operation; reading the data from the LCD. Data will be copied from the LCD data register to MCS-51 via the data bus (D0-D7), namely Pins 7–14 of the LCD. Conversely, if Pin 5 is given a voltage with logical 0 then the operation is a write operation; the signal will be sent from the MCS51 to LCD through the LCD Pins (Pins 7–14); The signal sent can be in the form of data or instructions depending on the logic level input to the Register Select-RS Pin, as described above before if RS = 0 then the signal sent is an instruction, vice versa if the RS = 1 then the signal sent/written is the data you want to display. Usually, Pin 5 of the LCD is connected with the power supply GND, because we will never read data from the LCD data register, but only send instructions for the LCD work configuration or the data you want to display on the LCD.

Pin 6 of the LCD (EN¯) is a Pin used to enable the LCD. The LCD will be enabled with the entry of changes in the signal level from high (1) to low (0) on Pin 6. If Pin 6 gets the voltage of logic level either 1 or 0 then the LCD will be disabled; it will only be enabled when there is a change of the voltage level in Pin 6 from high logic level to low logic level for more than 1000 microseconds (1 millisecond), and we can send either instruction or data to processed during that enable time of Pin 6.

Pin 3 and Pin 15 are used to regulate the brightness of the BPL (Back Plane Light). As mentioned above before the LCD operates on the principle of continuing or inhibiting the light passing through it; instead of producing light by itself. The light source comes from LED behind this LCD called BPL. Light brightness from BPL can be set by using a potentiometer or a trimpot. From Figure 6 Pin 3 (VEE) is used to regulate the brightness of BPL (by changing the current that enters BPL by using a potentiometers/a trimpot). While Pin 15 (BPL) is a Pin used for the sink of BPL LED.

4RSRegister selector on the LCD, if RS = 0 then the selected register is an instruction register (the operation to be performed is a write operation/LCD configuration if Pin 5 (R/W¯) is given a logic 0), if RS = 1 then the selected register is a data register; if (R/W¯) = 0 then the operation performed is a data write operation to the LCD, otherwise if (R/W¯) = 1 then the operation performed is a read operation (data will be sent from the LCD to μC (microcontroller); it is usually used to read the busy bit/Busy Flag- BF of the LCD (bit 7/D7).

5(R/W¯)Sets the operating mode, logic 1 for reading operations and logic 0 for write operations, the information read from the LCD to μC is data, while information written to the LCD from μC can be data to be displayed or instructions used to configure the LCD. Usually, this Pin is connected to the GND of the power supply because we will never read data from the LCD but only write instructions to configure it or write data to the LCD register to be displayed.

6Enable¯The LCD is not active when Enable Pin is either 1 or 0 logic. The LCD will be active if there is a change from logic 1 to logic 0; information can be read or written at the time the change occurs.

Initialize with a string constant in quotation marks; the compiler will size the array to fit the string constant and a terminating null character, Str4

Generally, strings are terminated with a null character (ASCII code 0). This allows functions (like Serial.print()) to tell where the end of a string is. Otherwise, they would continue reading subsequent bytes of memory that aren"t actually part of the string.

This means that your string needs to have space for one more character than the text you want it to contain. That is why Str2 and Str5 need to be eight characters, even though "arduino" is only seven - the last position is automatically filled with a null character. Str4 will be automatically sized to eight characters, one for the extra null. In Str3, we"ve explicitly included the null character (written "\0") ourselves.

Note that it"s possible to have a string without a final null character (e.g. if you had specified the length of Str2 as seven instead of eight). This will break most functions that use strings, so you shouldn"t do it intentionally. If you notice something behaving strangely (operating on characters not in the string), however, this could be the problem.

It is often convenient, when working with large amounts of text, such as a project with an LCD display, to setup an array of strings. Because strings themselves are arrays, this is in actually an example of a two-dimensional array.

In the code below, the asterisk after the datatype char "char*" indicates that this is an array of "pointers". All array names are actually pointers, so this is required to make an array of arrays. Pointers are one of the more esoteric parts of C for beginners to understand, but it isn"t necessary to understand pointers in detail to use them effectively here.

I checked theback of my lcd it is CMC216NO6, I think it is from CMC company, however I could not find related datasheet anywhere, any suggestion that where I could get it?

I was using the flex_lcd.c code foir a 2x16 lcd display and I was wandering if there"s anyway to keep a message on the first line solid while I a software counter on the second line of the LCD to simulate a stopwatch?

There are different versions of Character-Based LCD Displays, for example the more commons driven by the HD44780UA00 chip English-Japanese or the HD44780UA02 English-European:

The problem is that special characters above ASCII appear on various addresses in these screens. For example the ° symbol is not in the same location. Using ° in yaml config directly won"t render it correctly, \xdf is needed for the English-Japanese model, and \xb0 for the less common English-European.

Now to simply display °C you can"t just use return "\xdfC"; because C is a hex number, and the C standard does not define the maximum number of them in an \x escape sequence, so it is interpreted as part of it. To overcome this, you need to manually hack around with double-double quotes like return "\xdf""C"; otherwise unexpected data appears on the screen.

The LCD screens (and the lcd_pcf8574 / lcd_gpio components) also support adding a subset of user_characters which help with usage of diacritics in many languages.

The other problem is that using all these in strings is rather awkward, for example with the config below for Hőmérséklet we have to use H\x09m\x05rs\x05klet, but even worse, for Főcím we need to use F\x09""c\x07m (again need for a double-double quote).

How about having a user_map configuration item where the user could cherry pick which characters/symbols have which hex address (based on tables above + the user_characters) based on the needs and from then, no more need to care about these in the rest of the config, replacements should be done automatically (maybe within LCDDisplay::print?), no need for escapes and manual taking care of the occurrence of potential hex characters following them:

The new LCD menu component will likely raise the need to find a solution to these problems, as there the number of strings to be used will increase dramatically.

Granted, the Arduino doesn’t have much use for text when used on it’s own. It has no display. But a display can be attached, or text can be send/received through the serial port and other ways of communication.

We have used strings already a few times. Each time when we used a “Serial.print() ” or “Serial.println() “, we actually already used strings. Remember that a text in C needs to be enclosed in double quotes? That would make it a string.

First of all, we can use a “string” (all lowercase!) – where a string is a so called array of characters. In English that makes sense: it’s a “list” of characters.

Please consider disabling your ad blocker for our website.We rely on these ads to be able to run our website.You can of course support us in other ways (see Support Uson the left).

In the case of a string, the array keeps going, until your Arduino finds a NULL character. The NULL character terminates the string – or indicates the end of the string.

It’s character zero. But we do not (yet) have to worry about that – but it is something to keep in mind. Since strings are quite often used, the language “C” which we use for Arduino Programming, comes with a standard library of string related functions, which handle quite a lot already automatically.

What this does, is create an array of characters (which is a string), the empty square brackets basically says “compiler! Go figure out yourself how large this array should be“. If we would have entered a number, then that number should at least be big enough to hold our string plus one NULL character.

Note that if the number is bigger than the number of characters we need, then this will work just fine. However, your Arduino might allocate the extra characters as well and waste memory space as we’re not using it. On the other hand, if you expect the string to change in the program and all those characters might be needed, then you’d already be prepared.

Leaving length the string array (char variablename[] = “…”) undefined will make that the compiler determines the required size of the array – one time only!

The variable “Name” points to the memory location of the “H” character of the string, which is at position 0 (zero) and therefor has “0” as it’s index number.

If we send address the whole variable, “Name”, then it would return the address of “Name[0]” but your program will keep pulling up the next index, and the next, and the next, until it reaches that NULL character. So in the end, it will return the text of the string.

Not really. Remember how I said before that the variable (in our example “Name”) actually points to the memory location of the first element in the array? It’s a memory address, which is not the same as a string. Believe me, this is something you’ll run into quite often, and it’s one of the reason why I’m not a fan of the C-language (I’m more of a Pascal fan – and plenty of people will argue with me on that one).

Unfortunately this makes things more complicated, and we’d have to assign each character to the proper element. Thank goodness there is a function for that: strcpy() .

Please consider disabling your ad blocker for our website.We rely on these ads to be able to run our website.You can of course support us in other ways (see Support Uson the left).

Now sometimes we’d like to print for example double quotes, but just typing them into a string will not work – the string would break. The compiler will think you’re done after seeing the second double quotes and everyting remaining will become an unclear mess.

The code highlighting of the Arduino IDE text editor, will show you if a string “breaks” or not, by changing character colors in the string you just typed.

The first line shows us the wrong way of doing it. The keywords of importance are printed in orange en the string in a green-like color. But … our string has a chunk of black text in it. The word “guest” is black. It means that this is not part of the string, which is caused by the double quotes around the word “guest”.

The third line shows us the trick with the backslash. We placed them right before the special character, so the compiler knows that the next character is special and part of the string.

Note that when you want the next character to be special as well, then you’d need to “escape” those as well. For example if we add multiple double quotes around the word “guest”: Serial.println("Hello \"\"guest\"\", welcome to Arduino");

This trick has to be used for certain other characters as well, for example starting a new line is an ASCII character (see the character table, and look in the “Esc” column). If we’d like to place a line break (start a new line) in our string, then we would need ASCII character 10, which we write as “\n”.

The error message  invalid conversion from "const char*" to "char"  tells us that we are assigning the wrong kind of datatype to our array element. In simple words: This is because we are trying to assign a string to a character.

However, if our string becomes shorter, for example by replacing “Hans” with “Max” (my other nephew), then we would need to add the NULL character again:

Obviously, using ASCII is not the obvious way to do it when you’d like to assign text to a string. However, there are scenario’s where this can be very practical. I’ll illustrate this with a quick nonesense example, which quickly lists all the letters of the alphabet, where we can use a “for” loop to count from 65 (=A) to 90 (=Z).

The “for” loop can be used with numbers, or basically anything we can enumerate, or in other words: Data types that we can count with fixed increments, or whole numbers. For example, a byte, or an integer (both whole numbers):

Just keep in mind that a char can be “counted” as well, and this actually does work (see code below). Char is in essence a “byte”, and as we just have seen, we can assign it a number – so char can be counted as well, as if it’s a whole “number”.

Please consider disabling your ad blocker for our website.We rely on these ads to be able to run our website.You can of course support us in other ways (see Support Uson the left).

“strlen()” (read as: String Length) takes one parameter, a string, and returns the number of characters in the string. It will however not count the NULL character at the end.

“sizeof()” does the same thing as “strlen()”, however it will include the NULL character in it’s count. It actually returns the size of the full array, even if it would be filled with NULL characters.

What this does, is that the compiler will guess the required array space, one time only! This means that it will see the string “Hans” and will determine that these 4 characters will need an array of 5 characters (text plus NULL character).

When we added ” has two nephews, called Bram and Max!” to that string/array, we royally exceed the pre-defined space, and your Arduino will try to print that anyway. Not being able to find the NULL character (we have overwritten it with a non-NULL character, a space-character, in this example), it will keep spitting out whatever is in memory until it finds a NULL character. Which might be right away, or never …

The tedious and cumbersome things we had to do with the old “string” (lowercase: Array of Char), are done much easier with the “String” (Capital “S”: an object) object … but what is an object?

For one; everything is logically grouped together. There is no confusion to what item the properties or functions belong. So when we aks for properties or call a method (function) of a given object “car” then we know it only relates that that specific car.

Another reason is that once an object has been defined, it actually kind-a behaves like a data type, which can use for variables. Say we have one “car” then we create a variable “MyCar” as the object (data type) “car”. But if we have a garage filled with cars, then we can re-use that same definition to create multiple variables (MyCar, YourCar, DadsCar, MomsCar), or even an array of cars (Cars[0], Cars[1], Cars[2],…).

With “Serial” we have already seen the methods (functions) “begin”, “print” and “println”. We call these methods to have the object do something , like start communication, or send a string to our Serial Monitor of our Arduino IDE.

Maybe you’ve now seen that we always call an object in a format like this: OBJECT.METHOD or OBJECT.PROPERTY? We call the object and separate object and method (or property) with a period.

As mentioned and shown before: the array of char variant of a string is a little cumbersome to work with. So the good people at Arduino created an object to make working with strings easier. Again a reminder: it’s the “String” with a capital “S”!!!

As we have seen with the old “string”, we can simply create a variable and assign it a value in one single line. Nothing new there, well except for the keyword “String” of course and the lack of square brackets.

Line 10 could also be written as Name = String("Bram"); , which will actually work as well, but now we assign the new object (holding the string “Bram”) to the old object, versus the method in the code where we assign just a string to the object.

Now let’s make that string longer, in the previous example, when using the array of char “string”, we noticed that we had to pay attention to the size of the array, so we wouldn’t go beyond it’s capacity. The “String” object however saves us that worry. It corrects automatically.

You see? We can assign a much larger string than what we started out with, and when printing it, we experience zero problems. This is already a second point where the object is easier to use.

For two reasons. For one, the object will take up more memory, since it has all these fancy properties and methods. Another reason is that the String object, actually uses the “string” array of characters as well.

Please consider disabling your ad blocker for our website.We rely on these ads to be able to run our website.You can of course support us in other ways (see Support Uson the left).

Now the “String” object, has a lot of methods (functions) we can work with, which can make our life a lot easier when working with strings, and this is where we will really see the power of objects.

We create the String object “Name” and assign it the value “Hans” (lines 7 and 8), which we can print with “Serial” as we have seen before. Now in line 12, we retrieve the length of our string – which is just the number of characters in the string, and not including the NULL terminating character. This is done with the “length()” method of the “String” object: Name.length() . This method will return a number, an integer, which we send right away to “Serial.print”.

In line 14, we call the method “concat()” to concatenate ” has two nephews, called Bram and Max!” to the original string “Hans”. As you can see, this works right away. But … there is an easier way to glue an extra string to your “String” object by simply using the plus symbol (+), even the compound operator “+=” works. See lines 27 and 28, where we use “+=” and even the regular “+”.

The “String” object however is even more powerful and can right away convert a number (int in this example) to a string, and replace or attach it to an existing string – see line 34 – which is something we cannot do with the previous “string” array of characters.

Now if we know that String("some text") returns a “String” object, and we know that we can glue strings together with the plus symbol (+), and we know that “Serial.println()” take a “String” as a parameter,… then we can do some tricks to save us the hassle of writing 2 “Serial” lines (print() and println()) whenever we want to print values or variables.

The reason why this fails, is because we are comparing a string with the memory location “pointer” of an array. Which will not be the same obviuosly. We actually need to use a special function for this: “strcmp()”  (read that as “string compare”)

This functions returns a number less than zero when the first string is smaller than the second string, or returns a number greater than zero when the first string is larger than the second string.

When comparing the two strings, it will actually compare the ASCII values. So when it returns a number greater than zero, it actually means that it ran into a character which has a greater ASCII value compared to the other character, in the same position in the other string, and this can be confusing, because we humans would expect “Hans” to be greater than “Hi” – but its not. This is in part also because we humans see the longer string “Hans” as the larger one of the two.

Comparing “String” objects result in the same kind of confusion, but instead of using the “strcmp()” function, we can use the simple comparison operators.

If you have questions, just ask them below in the comment section, and keep in mind: There are no stupid questions! We all had to start at some point!

The provided display driver example code is designed to work with Microchip, however it is generic enough to work with other micro-controllers. The code includes display reset sequence, initialization and example PutPixel() function.

Please see the DT028CTFT for reference designs. The schematics between the B and the C are the same with the exception that the B does not have the IPS interface.

If you"re not tied to pgfplots, dataplot can handle quotes in the CSV file. It"s far more limited that pgfplots and if your real data is a lot larger than the data provided in your MWE it may not cope so well. However, I thought I may as well add this as a possible alternative in case it"s useful.