arduino lcd display no text quotation

It"s 16x2, i"ve written some code to print out text but the only thing that appears is the top row filled with boxes and the bottom row showing nothing..

I"ve read another forum talking about setting the LCD baud rate to my serial monitor rate, but i"m not sure how to do any of that. this is the product i bought: OSEPP - Multi Colored LED Assortment Set

My normal answer would be that you can use any available Arduino I/O pin for any of the LCD control or signal lines, but that is only true when you are doing the wiring between the two devices.

In this case the original poster did not tell us that he was using a shield. In that case the wiring between the two devices has already been done and your constructor (LiquidCrystal lcd(...)) must match that wiring.

Unfortunately this is one of the "bodgie" shields for which the warning at the top of this forum applies. It is all right as long as you never make pin 10 an output and write it HIGH - which also means you must not include it in the descriptor.

Unfortunately this is one of the "bodgie" shields for which the warning at the top of this forum applies. It is all right as long as you never make pin 10 an output and write it HIGH - which also means you must not include it in the descriptor.

Posting a monstrously huge picture is not necessary and posting any picture without specifying the code that produced it is usually a waste of time and bandwidth.

Posting a monstrously huge picture is not necessary and posting any picture without specifying the code that produced it is usually a waste of time and bandwidth.

Posting a monstrously huge picture is not necessary and posting any picture without specifying the code that produced it is usually a waste of time and bandwidth.

The simplest way to test the display does not involve cursor positioning at all. Just send 80 printable ASCII characters to the display and all of the character positions should be filled.

That actually just indicates an uninitialised display, meaning the HD44780 (clone) has not responded to the initialisation command, and is not generating the strobes for the second line.

The question then becomes, from where do those "noise" characters come, as they clearly do not correspond to the working code? I think the answer is that the LCD is seeing some activity on its inputs, but has not received the proper initialisation sequence.

That actually just indicates an uninitialised display, meaning the HD44780 (clone) has not responded to the initialisation command, and is not generating the strobes for the second line.

That actually just indicates an uninitialised display, meaning the HD44780 (clone) has not responded to the initialisation command, and is not generating the strobes for the second line.

Actually a single row of blocks (or two out of four rows) indicates an improperly initialized display controller. Typically the controller has not been initialized by your code so it retains the default initialization that should occur at power-up. This is for a single line display (a display using a single line of memory, not necessarily a display using a single row of characters). These single line displays use a a different multiplexing scheme with a different duty cycle, hence the dark row of blocks. Also the addressing scheme is different when you get beyond the first 40 characters.

As far as we are concerned there is no difference between an uninitialized and an improperly initialized display but the term improperly initialized is the correct one.

What do you see? Is the screen blank? Do you have one row of dark boxes? Do you have two rows of dark boxes? Do you have something else? Each of these symptoms is the result of a different cause so what does happen when your display "doesn"t work" can give valuable clues as to the cause.

I suggest that you disconnect everything and then follow the tutorial at Arduino Tutorial - connecting a parallel LCD. About halfway through the tutorial, just before the section labeled "Bus Wiring" is where the contrast is adjusted. If your potentiometer doesn"t work then you will have to be creative with the contrast pin. Some displays work adequately with this pin connected to GND so you should try that first. Most require a small positive voltage, usually less than 1 volt and some require a negative voltage (but those are rare, unless you got your display from a reputable dealer at a relatively low price). If you can"t get the display of a single row of moderately dark boxes then you need not continue.

By the way the LCD pins are numbered starting with 1, not 0, just like IC pins and the vacuum tube pins that preceded them. The contrast voltage is applied to pin 3 which you are incorrectly calling pin 2.

This stems from the fact that the LCD controller itself does not inherently support the function and in fact treats the ASCII codes for and as displayable characters instead of control codes.

The fact that the LiquidCrystal library inherits from Print class and thus permits the use of println() essentially makes things worse. Instead of barfing and spitting out an error message it just happily displays two unrelated characters on the screen and the uninitiated have no idea of the cause.

In my opinion the basic LiquidCrystal library should concentrate on implementing all of the capabilities of the LCD controller and no more. If people want a library that more closely emulates a CRT (or LCD) terminal that is fine, but I think it should be done in a different library.

OK so i recently purchased a 20x4 LCD made by Hacktronics http://www.hacktronics.com and i set it up with the following tutorial Arduino Character LCD Tutorial I then ran the code on the page and changed the 16,2 to 20,4 and uncommented the lines yet this is not working. The LCD lights up blue but no text is displayed. Im using 330 ohm resistors (im not sure exactly, but there blue with pink and black stripes) but nothing seems to help it. Thank you to anyone who might be able to help!!

We need a clear (focused) picture that unambiguously shows both ends of each wire that connects between your Arduino and your LCD module. It would help if the picture were oriented properly instead of being reversed. (Use two mirrors if you have to.)

We need a clear (focused) picture that unambiguously shows both ends of each wire that connects between your Arduino and your LCD module. It would help if the picture were oriented properly instead of being reversed. (Use two mirrors if you have to.)

Ok so Im really new to this stuff, does anyone know of a tutorial or something to help me? I don"t know how to get my petentiometer to do anything and I copied the picture on the website exactly and now the LCD won"t even light up, I don"t know what "size" the resistor is either. I"m sorry

Ok so Im really new to this stuff, does anyone know of a tutorial or something to help me? I don"t know how to get my petentiometer to do anything and I copied the picture on the website exactly and now the LCD won"t even light up, I don"t know what "size" the resistor is either. I"m sorry

Try the Tutorial at Arduino Tutorial - connecting a parallel LCD. Be careful with the backlight connections, the text tells all about the resistor but it does not show up in the photographs. It goes in place of the red wire at pin 15 or the black wire at pin 16.

Ok so Im really new to this stuff, does anyone know of a tutorial or something to help me? I don"t know how to get my petentiometer to do anything and I copied the picture on the website exactly and now the LCD won"t even light up, I don"t know what "size" the resistor is either. I"m sorry

Try the Tutorial at Arduino Tutorial - connecting a parallel LCD. Be careful with the backlight connections, the text tells all about the resistor but it does not show up in the photographs. It goes in place of the red wire at pin 15 or the black wire at pin 16.

On a second look maybe you did solder the pins. The picture was not good enough to convince me but since you didn"t say anything, I take it as yes you soldered the pins.

On a second look maybe you did solder the pins. The picture was not good enough to convince me but since you didn"t say anything, I take it as yes you soldered the pins.

One end goes to +5V (LCD pin 2), the other end goes to Ground (LCD pin 1), and the center terminal goes to LCD pin 3. Your potentiometer may physically look different but the connections are the same as those in the tutorial photographs.

One end goes to +5V (LCD pin 2), the other end goes to Ground (LCD pin 1), and the center terminal goes to LCD pin 3. Your potentiometer may physically look different but the connections are the same as those in the tutorial photographs.

Alright so i did this and followed a tutorial but its still just lighting up as a blue screen. I think the problem is that the contrast is not working. ARRRGGHHHH! I"m frustrated, thank you for your help. Is there any pictures i could post that would be helpful?

It"s the incorrect way to apply the power to the actual display itself. You should use a 10 K ohm (plus or minus a few hundred percent) potentiometer with the ends connected to +5 V and GND and the center connected to pin 3. This is commonly called the "contrast" control.

Ok so I hooked up the petentiometer to 5v and GBD and the third pin bus however I turn the contrast nothing happens. Should pin 3 be connected to anything other than the wiper

May I jump in and ask a question? I know the link to Arduino Reference but where can I read about the F-macro? Maybe there are more useful Macros that I don"t know about, "somewhere".

I think I first ran across the F() macro in someone"s answer to a quest on this forum, and the rest I learned from google (which mostly gives references to discussions on here), not really sure if there is a reference page on it.

What that code does is create an array of char pointers, that point to where the actual text is stored in memory, while also doing all the work of storing the individual text strings in memory and keeping track of where they are.

To retrieve the values from PROGMEM, you then would use (char *)pgm_read_word(&lcdtext[pokemonvalue][0]) , which tells the compiler to read a two-byte value (a word) from the lcdtext array, and to treat that value as a char *. That will work fine in a print statement, except that the actual text is not being stored in program memory, only the array of pointers to the text.

To store the text itself in program memory, you need to store each line of text separately, giving each a unique name, then create the array of characters pointers from that:

Now when you want to reference the text in a print command, you would use (__FlashStringHelper *)pgm_read_word(&lcdtext[pokemonvalue][0]) , with __FlashStringHelper * serving the same purpose as char * above, but specifying to the compiler that the memory pointed to is in program memory.

Now for the reason for creating the array. Instead of using a very large, repetitive switch...case structure to print out text for each value of pokemonvalue, it is much simpler to put the text in an array, and use pokemonvalue to specify which element of the array you want to print. The entire switch...case statement can be replace with three lines of code:

I am attempting to get my lcd up and running to print out a simple hello world. I am able to get the display to turn on, but whenever I upload the program to the board it will not display text. I have attached pictures of my wiring on the breadboard and on the Arduino, picture of the lcd being on, the code I am running, and a link to the schematic I used.

EDIT: Sorry guys, I thought I changed my picture format. This should be viewable now!! Also, When I initially turn it on it will display boxes on half of the screen that will slowly fade, almost as if it is "dying" unsure if thats useful.

In this tutorial, I’ll explain how to set up an LCD on an Arduino and show you all the different ways you can program it. I’ll show you how to print text, scroll text, make custom characters, blink text, and position text. They’re great for any project that outputs data, and they can make your project a lot more interesting and interactive.

The display I’m using is a 16×2 LCD display that I bought for about $5. You may be wondering why it’s called a 16×2 LCD. The part 16×2 means that the LCD has 2 lines, and can display 16 characters per line. Therefore, a 16×2 LCD screen can display up to 32 characters at once. It is possible to display more than 32 characters with scrolling though.

The code in this article is written for LCD’s that use the standard Hitachi HD44780 driver. If your LCD has 16 pins, then it probably has the Hitachi HD44780 driver. These displays can be wired in either 4 bit mode or 8 bit mode. Wiring the LCD in 4 bit mode is usually preferred since it uses four less wires than 8 bit mode. In practice, there isn’t a noticeable difference in performance between the two modes. In this tutorial, I’ll connect the LCD in 4 bit mode.

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.

Here’s a diagram of the pins on the LCD I’m using. The connections from each pin to the Arduino will be the same, but your pins might be arranged differently on the LCD. Be sure to check the datasheet or look for labels on your particular LCD:

Also, you might need to solder a 16 pin header to your LCD before connecting it to a breadboard. Follow the diagram below to wire the LCD to your Arduino:

All of the code below uses the LiquidCrystal library that comes pre-installed with the Arduino IDE. A library is a set of functions that can be easily added to a program in an abbreviated format.

In order to use a library, it needs be included in the program. Line 1 in the code below does this with the command #include . When you include a library in a program, all of the code in the library gets uploaded to the Arduino along with the code for your program.

Now we’re ready to get into the programming! I’ll go over more interesting things you can do in a moment, but for now lets just run a simple test program. This program will print “hello, world!” to the screen. Enter this code into the Arduino IDE and upload it to the board:

There are 19 different functions in the LiquidCrystal library available for us to use. These functions do things like change the position of the text, move text across the screen, or make the display turn on or off. What follows is a short description of each function, and how to use it in a program.

TheLiquidCrystal() function sets the pins the Arduino uses to connect to the LCD. You can use any of the Arduino’s digital pins to control the LCD. Just put the Arduino pin numbers inside the parentheses in this order:

This function sets the dimensions of the LCD. It needs to be placed before any other LiquidCrystal function in the void setup() section of the program. The number of rows and columns are specified as lcd.begin(columns, rows). For a 16×2 LCD, you would use lcd.begin(16, 2), and for a 20×4 LCD you would use lcd.begin(20, 4).

This function clears any text or data already displayed on the LCD. If you use lcd.clear() with lcd.print() and the delay() function in the void loop() section, you can make a simple blinking text program:

This function places the cursor in the upper left hand corner of the screen, and prints any subsequent text from that position. For example, this code replaces the first three letters of “hello world!” with X’s:

Similar, but more useful than lcd.home() is lcd.setCursor(). This function places the cursor (and any printed text) at any position on the screen. It can be used in the void setup() or void loop() section of your program.

The cursor position is defined with lcd.setCursor(column, row). The column and row coordinates start from zero (0-15 and 0-1 respectively). For example, using lcd.setCursor(2, 1) in the void setup() section of the “hello, world!” program above prints “hello, world!” to the lower line and shifts it to the right two spaces:

You can use this function to write different types of data to the LCD, for example the reading from a temperature sensor, or the coordinates from a GPS module. You can also use it to print custom characters that you create yourself (more on this below). Use lcd.write() in the void setup() or void loop() section of your program.

The function lcd.noCursor() turns the cursor off. lcd.cursor() and lcd.noCursor() can be used together in the void loop() section to make a blinking cursor similar to what you see in many text input fields:

Cursors can be placed anywhere on the screen with the lcd.setCursor() function. This code places a blinking cursor directly below the exclamation point in “hello, world!”:

This function creates a block style cursor that blinks on and off at approximately 500 milliseconds per cycle. Use it in the void loop() section. The function lcd.noBlink() disables the blinking block cursor.

This function turns on any text or cursors that have been printed to the LCD screen. The function lcd.noDisplay() turns off any text or cursors printed to the LCD, without clearing it from the LCD’s memory.

These two functions can be used together in the void loop() section to create a blinking text effect. This code will make the “hello, world!” text blink on and off:

This function takes anything printed to the LCD and moves it to the left. It should be used in the void loop() section with a delay command following it. The function will move the text 40 spaces to the left before it loops back to the first character. This code moves the “hello, world!” text to the left, at a rate of one second per character:

This function takes a string of text and scrolls it from right to left in increments of the character count of the string. For example, if you have a string of text that is 3 characters long, it will shift the text 3 spaces to the left with each step:

Like the lcd.scrollDisplay() functions, the text can be up to 40 characters in length before repeating. At first glance, this function seems less useful than the lcd.scrollDisplay() functions, but it can be very useful for creating animations with custom characters.

lcd.noAutoscroll() turns the lcd.autoscroll() function off. Use this function before or after lcd.autoscroll() in the void loop() section to create sequences of scrolling text or animations.

This function sets the direction that text is printed to the screen. The default mode is from left to right using the command lcd.leftToRight(), but you may find some cases where it’s useful to output text in the reverse direction:

This code prints the “hello, world!” text as “!dlrow ,olleh”. Unless you specify the placement of the cursor with lcd.setCursor(), the text will print from the (0, 1) position and only the first character of the string will be visible.

This command allows you to create your own custom characters. Each character of a 16×2 LCD has a 5 pixel width and an 8 pixel height. Up to 8 different custom characters can be defined in a single program. To design your own characters, you’ll need to make a binary matrix of your custom character from an LCD character generator or map it yourself. This code creates a degree symbol (°):

If you found this article useful, subscribe via email to get notified when we publish of new posts! And as always, if you are having trouble with anything, just leave a comment and I’ll try to help you out.

I"ve checked all connections and they look good. I am not 100%sure I have connected the potentiometer correctly, as this is the symptom I usually found online.

Update 2: I realised that this is a 20-pin LCD screen and re-reading the datasheet and some online tutorials I switched digital wire connections to pins to the LCD 7-10 (DB0-DB3) - same result and then 11-14 (DB4-DB7) - garbled output, shown below. Still no idea what is wrong.

This article includes everything you need to know about using acharacter I2C LCD with Arduino. I have included a wiring diagram and many example codes to help you get started.

In the second half, I will go into more detail on how to display custom characters and how you can use the other functions of the LiquidCrystal_I2C library.

Once you know how to display text and numbers on the LCD, I suggest you take a look at the articles below. In these tutorials, you will learn how to measure and display sensor data on the LCD.

Each rectangle is made up of a grid of 5×8 pixels. Later in this tutorial, I will show you how you can control the individual pixels to display custom characters on the LCD.

They all use the same HD44780 Hitachi LCD controller, so you can easily swap them. You will only need to change the size specifications in your Arduino code.

The 16×2 and 20×4 datasheets include the dimensions of the LCD and you can find more information about the Hitachi LCD driver in the HD44780 datasheet.

Note that an Arduino Uno with the R3 layout (1.0 pinout) also has the SDA (data line) and SCL (clock line) pin headers close to the AREF pin. Check the table below for more details.

After you have wired up the LCD, you will need to adjust the contrast of the display. On the I2C module, you will find a potentiometer that you can turn with a small screwdriver.

The LiquidCrystal_I2C library works in combination with the Wire.h library which allows you to communicate with I2C devices. This library comes pre-installed with the Arduino IDE.

To install this library, go to Tools > Manage Libraries (Ctrl + Shift + I on Windows) in the Arduino IDE. The Library Manager will open and update the list of installed libraries.

*When using the latest version of the LiquidCrystal_I2C library it is no longer needed to include the wire.h library in your sketch. The other library imports wire.h automatically.

Note that counting starts at 0 and the first argument specifies the column. So lcd.setCursor(2,1) sets the cursor on the third column and the second row.

Next the string ‘Hello World!’ is printed with lcd.print("Hello World!"). Note that you need to place quotation marks (” “) around the text since we are printing a text string.

The example sketch above shows you the basics of displaying text on the LCD. Now we will take a look at the other functions of the LiquidCrystal_I2C library.

This function turns on automatic scrolling of the LCD. This causes each character output to the display to push previous characters over by one space.

If the current text direction is left-to-right (the default), the display scrolls to the left, if the current direction is right-to-left, the display scrolls to the right.

I would love to know what projects you plan on building (or have already built) with these LCDs. If you have any questions, suggestions or if you think that things are missing in this tutorial, please leave a comment down below.

What is the purpose of declaring LiquidCrystal_I2C lcd(0x27, 2, 1, 0, 4, 5, 6, 7, 3, POSITIVE); if we are using pins A4 and A5? I know that 0x27 is the ic address but what is the rest for?

there is a bit more but i"ll leave that for you to look into. in a more sophisticated IDE you normally can right click to a sub menu that will take you to the definition. it"s a great way to help you get a deeper understanding of how things work.0

I am getting a error while i m going to add zip file of lcd library error id this zip file does not contains a valid library please help me to resolve this issue as soon as possible.....

Hey guys. My LCD works fine using the above instructions (when replacing the existing LCD library in the Arduino directory) but I can"t get the backlight to ever switch off. Suggestions?

Hello friend welcome to “Techno-E-Solution” in this article we are going to learn how to connect LCD display with Arduino Uno and print "Hello World!" on LCD using Arduino Uno. The 16x2 LCD is most popular LCD in electronics projects. In upcoming project we need this display in our project so it"s the beginners level tutorial learn this tutorial with fun. So friends let"s get started..........

A PCB Design Problems Detector, An Engineering Solution Provider Import the Gerber file with one click. No need for complicated file reading steps to review easily and improve efficiency.

In a number of applications there is need to display text or characters, for example in calculators, digital clocks and other devices. This is where a Liquid Crystal Display (LCD) comes in handy. In this tutorial I’ll show you how to interface a 16×2 LCD with Arduino.

LCD is short for Liquid Crystal Display which means this display uses liquid crystals to produce a visible image. When current is applied to these crystals, they turn opaque and block the backlight behind the screen and as a result that particular area will become dark compared to other. And that’s how characters are displayed on the screen.

Most of the common LCDs with 16 pins use the Hitachi HD44780 driver which is a parallel interface LCD controller chip. In this case we are using a 16×2 LCD which means it has 2 rows and 16 columns. Therefore this LCD can display 32 ASCII characters although more characters can be displayed by scrolling.

The LCDs come in other sizes like 16×1, 16×4, 20×4 but the code for running these screens remains the same. The LCD screen is made of pixel rectangles for displaying the characters. Each of these rectangles is made up of grids of 5×8 pixels as illustrated in the diagram below.

V0: controls the contrast and brightness of the LCD. Using a simple voltage divider with a potentiometer, we can make fine adjustments to the contrast.

RS(Register Select): this pin is used to differentiate commands from data. When RS pin is set to LOW, then we are sending commands to the LCD and when RS pin is set on HIGH we are sending data/characters to the LCD.

RW(Read/Write): This pin is for determining whether you are reading or writing data from the LCD. In this case the LCD is being used as an OUTPUT device therefore we need to keep this pin LOW to keep it in the WRITE mode.

E(Enable): Used for enabling the display. When this pin is set to LOW, the LCD does not care what is happening with R/W, RS, and the data bus lines. When this pin is set to HIGH, the LCD is processing the incoming data. When we need to execute an instruction, this pin is set as HIGH for a few milliseconds then back to LOW.

This display can be wired in either 4 bit mode or 8 bit mode. In most cases we use the 4 bit mode since it uses less I/O pins than the 8 bit mode. However the 8-bit mode is faster in transmitting data because all the data is written at once unlike the 4-bit mode where the data is split into two packets before writing hence needing 2 write operations thereby taking more time.

We will use just 6 digital input pins from the Arduino Board. The LCD’s registers from D4 to D7 will be connected to Arduino’s digital pins from 4 to 7. The Enable pin will be connected to pin number 2 and the RS pin will be connected to pin number 1.

To control the LCD with Arduino we need to install the LiquidCrystal.h library which contains all the functions for controlling data transmission to the display. This library usually comes pre-installed in the Arduino IDE but can also be got from the Arduino community website.

LiquidCrystal(): Used for creating an LCD object and the parameters of this object should be the numbers of the digital input pins for controlling the LCD. The syntax is LiquidCrystal(RS, Enable, D4, D5, D6, D7).

lcd.begin(): For setting the dimensions of the LCD. The number of rows and columns are specified as lcd.begin(columns, rows). For a 16×2 LCD, you would use lcd.begin(16,2)

lcd.Cursor(): This function creates a visible cursor. The cursor is a horizontal line placed below the next character to be printed to the LCD. To turn the cursor off we use the lcd.noCursor() function.

lcd.blink(): This function is used for displaying a blinking cursor. Use it in the void loop() section. The lcd.noBlink() functions disables the blinking cursor.

lcd.setCursor(): Place the cursor or any printed text at any position on the screen. This function’s syntax is lcd.setCursor(column, row) where the column and row coordinates are in the range 0 to 15 and 0 to 1 respectively.

lcd.print(): For printing text on the LCD. To print letters and words, place quotation marks (” “) around the text. For example, to print hello, world!, use lcd.print(“hello, world!”). To print numbers, no quotation marks are necessary. For example, to print 123456789, use lcd.print(123456789).

Sometimes there is a need to display messages with more than 16 characters on the LCD screen and in that case we need to apply some form of scrolling effect to be able to display the whole text message. The LiquidCrystal library has functions to necessitate this and these include:

lcd.noAutoscroll(): This is the opposite of the lcd.autoscroll() function and is normally used before or after lcd.autoscroll() to create sequences of scrolling text or animations.

lcd.scrollDisplayLeft(): This function moves the text printed on the LCD to the left. It is should be followed by a delay command to control the speed of scrolling. The function will move the text 40 spaces to the left before it loops back to the first character. Text strings longer than 40 spaces will be printed to line 1 after the 40th position, while the start of the string will continue printing to line 0.

The code below is for scrolling the text “Hello World” in the left and right directions using the scrollDisplayLeft() and scrollDisplayRight() functions. The scrolling is done by incrementing the position of the text by one in the respective direction.

The major part of this code occurs in the loop section which includes counters made using for loops. In this case, the first counter scrolls the text left by 13 positions, which is enough to move it off the display to the left.

The last counter moves the text 16 positions to the left again, which will restore it back to the center of the display. The loop then repeats itself.

In case you need specific qualities in the way the text is scrolled on the LCD or if you want to display messages which are longer than 40 characters , then you can achieve this using custom functions. For example the code below shows how we can use custom functions to display a scrolling message on the display.

I have created a function scrollText() for scrolling text. This function accepts four arguments; the row on which to display the scrolling text, the text to be displayed, the delay time between the shifting of characters, and the number of columns of the LCD.

If you need to display a character that is not part of the standard 127-character ASCII character set then you might need to create your own characters .The Hitach HD44780 controller contains two types of memory:

CGROM: This is the Character Generator ROM which is the type of memory used for storing the permanent ASCII code fonts. These fonts are the ones we normally use for displaying messages on the LCD.

CGRAM: This is where the user defined characters are stored. This memory space can be modified and is limited to 64 bytes. This means that for a 5×8 based LCD, a maximum of eight custom characters can be stored in the CGRAM.

I have discussed more on how to display custom characters on the LCD in my other tutorial involving the use of an i2C adapter attached to the LCD to further reduce on the number of connections needed to run this display. You can check it out using this link:

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.

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.

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).

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");

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).

“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.

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 …

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.

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.

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”.

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”)

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.

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!

When I powered up my K8400 printer for the first time the LCD display lit up but there was no text message. I rotated the trimmer on the LCD to change the contrast but still no text.

I started “VERTEX 3D PRINTER Repetier-Host” and I could see the temperature. After this I could not continue with the start up guide due to that the LCD display wont show any text.

I switched all 1.5A DRIVER BOARD’s in every possible combination but still no text. I also removed all the 1.5A DRIVER BOARD’s and powered it up, but still no text.