can a arduino nano run a tft display quotation

Is there a difference between the NANO and MEGA that would account for ST7735 displays working on NANO and not working on MEGA? I"m using the same pins on both....

Now learning arduino tft, got a cheap 1.8 tft spi display from ebay, trying the arduino TFTDsiplayText example with potentiometer, and all my "goal" is the white screen.

This website is using a security service to protect itself from online attacks. The action you just performed triggered the security solution. There are several actions that could trigger this block including submitting a certain word or phrase, a SQL command or malformed data.

First of all, at the beginning of the source code, the author put this conditional SPI initialization that I think supports specific boards other than Arduino boards.

so this check starts with checking if it"s using arduino SPI library, if it"s another SPI library not the one in arduino core libraries folder, then this check is passed.

but also I don"t understand this author, why he/she would put SPI initialization/speed configuration at the beginning of the source file and in the void "ILI9488::begin(void)" function ?

This website is using a security service to protect itself from online attacks. The action you just performed triggered the security solution. There are several actions that could trigger this block including submitting a certain word or phrase, a SQL command or malformed data.

This website is using a security service to protect itself from online attacks. The action you just performed triggered the security solution. There are several actions that could trigger this block including submitting a certain word or phrase, a SQL command or malformed data.

The NANO-EVERY is 5V. All TFTs require 3.3V logic. Hence level shifters are needed for every logic signal (the controller VCC pin is powered by 3.3V).

Displays are one of the best ways to provide feedback to users of a particular device or project and often the bigger the display, the better. For today’s tutorial, we will look on how to use the relatively big, low cost, ILI9481 based, 3.5″ Color TFT display with Arduino.

This 3.5″ color TFT display as mentioned above, is based on the ILI9481 TFT display driver. The module offers a resolution of 480×320 pixels and comes with an SD card slot through which an SD card loaded with graphics and UI can be attached to the display. The module is also pre-soldered with pins for easy mount (like a shield) on either of the Arduino Mega and Uno, which is nice since there are not many big TFT displays that work with the Arduino Uno.

The module is compatible with either of the Arduino Uno or the Arduino Mega, so feel free to choose between them or test with both. As usual, these components can be bought via the links attached to them.

One of the good things about this module is the ease with which it can be connected to either of the Arduino Mega or Uno. For this tutorial, we will use the Arduino Uno, since the module comes as a shield with pins soldered to match the Uno’s pinout. All we need to do is snap it onto the top of the Arduino Uno as shown in the image below, thus no wiring required.

This ease of using the module mentioned above is, however, one of the few downsides of the display. If we do not use the attached SD card slot, we will be left with 6 digital and one analog pin as the module use the majority of the Arduino pins. When we use the SD card part of the display, we will be left with just 2 digital and one analog pin which at times limits the kind of project in which we can use this display. This is one of the reasons while the compatibility of this display with the Arduino Mega is such a good news, as the “Mega” offers more digital and analog pins to work with, so when you need extra pins, and size is not an issue, use the Mega.

To easily write code to use this display, we will use the GFX and TFT LCD libraries from “Adafruit” which can be downloaded here. With the library installed we can easily navigate through the examples that come with it and upload them to our setup to see the display in action. By studying these examples, one could easily learn how to use this display. However, I have compiled some of the most important functions for the display of text and graphics into an Arduino sketch for the sake of this tutorial. The complete sketch is attached in a zip file under the download section of this tutorial.

As usual, we will do a quick run through of the code and we start by including the libraries which we will use for the project, in this case, the Adafruit GFX and TFT LCD libraries.

With this done, the Void Setup() function is next. We start the function by issuing atft.reset() command to reset the LCD to default configurations. Next, we specify the type of the LCD we are using via the LCD.begin function and set the rotation of the TFT as desired. We proceed to fill the screen with different colors and display different kind of text using diverse color (via the tft.SetTextColor() function) and font size (via the tft.setTextSize() function).

Next is the void loop() function. Here we basically create a UI to display the youtube subscribe button, using some of the same functions we used under the void setup() function.

The Adafruit library helps reduce the amount of work one needs to do while developing the code for this display, leaving the quality of the user interface to the limitations of the creativity and imagination of the person writing the code.

That’s it for this tutorial guys, thanks for reading. If you made some cool projects based on this or you just want to ask questions about this tutorial, feel free to reach out via the comment section below.

For the last day, I"ve been trying to get the library to work with an Arduino Nano RP2040 + IL9341 SPI (https://smile.amazon.co.uk/gp/product/B07QJW73M3/ref=ppx_yo_dt_b_search_asin_title?ie=UTF8&psc=1 ).

I don"t rule the fact I might be getting something wrong, but can anyone confirm they got TFT_eSPI working on an actual Arduino RP2040 (NOT the Raspberry Pico) ?

Next thing I"ll try is the Adafruit_ILI9341 library, since there are actual videos of people using that combination (AdaFruit_ILI9341 + Arduino RP2040 + SPI screen).

In this Arduino touch screen tutorial we will learn how to use TFT LCD Touch Screen with Arduino. You can watch the following video or read the written tutorial below.

For this tutorial I composed three examples. The first example is distance measurement using ultrasonic sensor. The output from the sensor, or the distance is printed on the screen and using the touch screen we can select the units, either centimeters or inches.

The next example is controlling an RGB LED using these three RGB sliders. For example if we start to slide the blue slider, the LED will light up in blue and increase the light as we would go to the maximum value. So the sliders can move from 0 to 255 and with their combination we can set any color to the RGB LED,  but just keep in mind that the LED cannot represent the colors that much accurate.

The third example is a game. Actually it’s a replica of the popular Flappy Bird game for smartphones. We can play the game using the push button or even using the touch screen itself.

As an example I am using a 3.2” TFT Touch Screen in a combination with a TFT LCD Arduino Mega Shield. We need a shield because the TFT Touch screen works at 3.3V and the Arduino Mega outputs are 5 V. For the first example I have the HC-SR04 ultrasonic sensor, then for the second example an RGB LED with three resistors and a push button for the game example. Also I had to make a custom made pin header like this, by soldering pin headers and bend on of them so I could insert them in between the Arduino Board and the TFT Shield.

Here’s the circuit schematic. We will use the GND pin, the digital pins from 8 to 13, as well as the pin number 14. As the 5V pins are already used by the TFT Screen I will use the pin number 13 as VCC, by setting it right away high in the setup section of code.

As the code is a bit longer and for better understanding I will post the source code of the program in sections with description for each section. And at the end of this article I will post the complete source code.

I will use the UTFT and URTouch libraries made by Henning Karlsen. Here I would like to say thanks to him for the incredible work he has done. The libraries enable really easy use of the TFT Screens, and they work with many different TFT screens sizes, shields and controllers. You can download these libraries from his website, RinkyDinkElectronics.com and also find a lot of demo examples and detailed documentation of how to use them.

After we include the libraries we need to create UTFT and URTouch objects. The parameters of these objects depends on the model of the TFT Screen and Shield and these details can be also found in the documentation of the libraries.

Next we need to define the fonts that are coming with the libraries and also define some variables needed for the program. In the setup section we need to initiate the screen and the touch, define the pin modes for the connected sensor, the led and the button, and initially call the drawHomeSreen() custom function, which will draw the home screen of the program.

So now I will explain how we can make the home screen of the program. With the setBackColor() function we need to set the background color of the text, black one in our case. Then we need to set the color to white, set the big font and using the print() function, we will print the string “Arduino TFT Tutorial” at the center of the screen and 10 pixels  down the Y – Axis of the screen. Next we will set the color to red and draw the red line below the text. After that we need to set the color back to white, and print the two other strings, “by HowToMechatronics.com” using the small font and “Select Example” using the big font.

Next is the distance sensor button. First we need to set the color and then using the fillRoundRect() function we will draw the rounded rectangle. Then we will set the color back to white and using the drawRoundRect() function we will draw another rounded rectangle on top of the previous one, but this one will be without a fill so the overall appearance of the button looks like it has a frame. On top of the button we will print the text using the big font and the same background color as the fill of the button. The same procedure goes for the two other buttons.

Now we need to make the buttons functional so that when we press them they would send us to the appropriate example. In the setup section we set the character ‘0’ to the currentPage variable, which will indicate that we are at the home screen. So if that’s true, and if we press on the screen this if statement would become true and using these lines here we will get the X and Y coordinates where the screen has been pressed. If that’s the area that covers the first button we will call the drawDistanceSensor() custom function which will activate the distance sensor example. Also we will set the character ‘1’ to the variable currentPage which will indicate that we are at the first example. The drawFrame() custom function is used for highlighting the button when it’s pressed. The same procedure goes for the two other buttons.

drawDistanceSensor(); // It is called only once, because in the next iteration of the loop, this above if statement will be false so this funtion won"t be called. This function will draw the graphics of the first example.

getDistance(); // Gets distance from the sensor and this function is repeatedly called while we are at the first example in order to print the lasest results from the distance sensor

So the drawDistanceSensor() custom function needs to be called only once when the button is pressed in order to draw all the graphics of this example in similar way as we described for the home screen. However, the getDistance() custom function needs to be called repeatedly in order to print the latest results of the distance measured by the sensor.

Here’s that function which uses the ultrasonic sensor to calculate the distance and print the values with SevenSegNum font in green color, either in centimeters or inches. If you need more details how the ultrasonic sensor works you can check my particular tutorialfor that. Back in the loop section we can see what happens when we press the select unit buttons as well as the back button.

Ok next is the RGB LED Control example. If we press the second button, the drawLedControl() custom function will be called only once for drawing the graphic of that example and the setLedColor() custom function will be repeatedly called. In this function we use the touch screen to set the values of the 3 sliders from 0 to 255. With the if statements we confine the area of each slider and get the X value of the slider. So the values of the X coordinate of each slider are from 38 to 310 pixels and we need to map these values into values from 0 to 255 which will be used as a PWM signal for lighting up the LED. If you need more details how the RGB LED works you can check my particular tutorialfor that. The rest of the code in this custom function is for drawing the sliders. Back in the loop section we only have the back button which also turns off the LED when pressed.

In order the code to work and compile you will have to include an addition “.c” file in the same directory with the Arduino sketch. This file is for the third game example and it’s a bitmap of the bird. For more details how this part of the code work  you can check my particular tutorial. Here you can download that file:

drawDistanceSensor(); // It is called only once, because in the next iteration of the loop, this above if statement will be false so this funtion won"t be called. This function will draw the graphics of the first example.

getDistance(); // Gets distance from the sensor and this function is repeatedly called while we are at the first example in order to print the lasest results from the distance sensor

3. What if Adafruit libraries are not displaying with the desired colors. This is a little hard to solve. Our suggestion, create a small function that display each color and note the number. Affordable electronics require a little more hacking, that"s all, it"s part of the fun. Check the following colors first, and adjust accordingly.

Because the Arduino Serial Monitor removes line endings uLisp ignores all characters after a semicolon up to the next opening bracket. This imposes a couple of restrictions in the use of comments:

As of uLisp 3.6, a comment line turns off echo so that a long listing can safely be pasted in to the Arduino IDE"s Serial Monitor without overflowing the serial buffer. Echo is turned back on automatically after a one second delay if there is no activity on the serial input.

Evaluates its arguments until one returns nil, and returns the last value. It"s usually used to combine conditions. For example, pos tests whether something is a positive number:

Returns the result of evaluating the function specified by the first argument with the list of arguments specified by the second parameter. So, for example:

The aref function can also be used with the in-place operations setf, incf, and decf to change an element of an array; for example, to change the value of an array element:

When the (break) function is evaluated you will be returned to the uLisp prompt, and you can then examine the values of parameters and local variables.

The case special form evaluates a keyform to produce a test key, and then tests this against a series of arguments, each of which is a list containing a key optionally followed by one or more forms.

If the test key equals the key the forms are evaluated, and the last value is returned as the result of the case. Otherwise none of the forms are evaluated, and the next argument is processed in the same way.

Joins together the strings given in the second and subsequent arguments, and returns a single string. The second argument specifies the type of the result; uLisp only supports string.

This creates a function called sq with one parameter, x. When the function is called, the body is evaluated with x bound to the argument. For example:

You can specify optional arguments by giving the &optional keyword followed by the parameters you want to make optional. If an argument is not specified for an optional parameter it will have the value nil. For example, the following function rec calculates the area of a rectangle:

You can specify a default value for any optional argument by specifying a list consisting of the optional argument followed by an expression. For example, the above definition could be written:

You can define a function that takes a variable number of arguments by giving the &rest keyword followed by a single parameter; this parameter is bound to a list of the remaining arguments.

You can add documentation to a function by adding a documentation string docstring after the parameters. You can then display this using ? or documentation.

On the 16-bit platforms the maximum delay is 32767, or approximately 32 seconds. On the 32-bit platforms the maximum delay is 2147483647, or approximately 24 days.

Executes the forms number times, with the local variable var set to each integer from 0 to number-1 in turn. It then returns result, or nil if result is omitted.

To edit the function you type a series of a or d commands to step through the function to the part you want to edit, use r, c, or x to make changes, type b to go back, or type q to exit from the editor.

If you type an invalid key the editor prints ?, and if you reach the end of the tree with a or d the editor prints !. For more information see Using the program editor.

Note that for the editor to work properly you need to have the line ending option set to Newline on the pop-up menu at the bottom of the Serial Monitor window.

Each of the directives ~a, ~s, ~d, ~g, ~b, or ~x can include a width parameter after the tilde, and the output is padded with spaces to the specified width. If the output wouldn"t fit in the specified width it is output in full, and overflows the width. The ~a and ~s directives pad with spaces to the right; all the other directives pad with spaces to the left. In uLisp this is the only difference between ~a and ~d or ~g.

The directives ~d, ~g, ~b, or ~x can also include a pad character, which is output in place of spaces to fill the argument to the specified width. The pad character is specified after the width, separated by a comma and a single quote. The pad character is useful combined with the width character for formatting output to be displayed on output devices such as seven-segment displays; for example:

The ~{ and ~} directives allow you to format elements in a list. The argument must be a list, and the format directives between ~{ and ~} are repeated until all the items in the list have been used. For example:

The ~^ directive exits from the directives between ~{ and ~} if the list being processed is finished. It is useful if you want to put a delimiter between list elements, but not after the last one. For example, to convert a Lisp list to JavaScript format you could use:

On the 16-bit platforms the maximum delay is approximately 32 seconds. On the 32-bit platforms the maximum delay is approximately 24 days. If the execution of the body takes longer than this for-millis returns nil.

Creates an unnamed function with parameters. The body is evaluated with the parameters as local variables whose initial values are defined by the values of the forms after the lambda form.

Functions are usually defined with a specified name using defun. The usual use of lambda is to create an unnamed function as the argument for a function such as mapc or mapcar. For details of the options see defun.

It is also used when you want to create a function that returns a function. The following example defines a function do2 that takes a function of one argument, and returns a function that performs that function twice:

In its simplest form you can declare a list of one or more variables which will be initialised to nil, and these can then be used in the subsequent forms:

If size is an integer make-array creates a one-dimensional array with elements from 0 to size-1. By default they are initialised to nil, but you can provide a default value with the :initial-element keyword parameter. For example:

N-dimensional arrays are printed using the notation #nA( ... ), where n is the number of dimensions in the array. For example, the above array is printed as:

The function mapc is like mapcar, but it doesn"t accumulate a list of results, and so is used for its side-effects. For example, if you had an RGB LED connected to I/O pins 9, 10, and 11 you could set the colour of the LED to yellow with:

Applies the function to each element in one or more lists. The results should be lists, and these are appended together to give the value returned by mapcan.

One use for mapcan is as a filter, to filter elements from a list if they don"t meet a specified predicate. For example, to extract just the even numbers from a list:

Returns the time in milliseconds that uLisp has been running. On 8/16-bit versions of uLisp this is a signed 16-bit number, so after 32.767 seconds the number will wrap around from 32767 to -32768. In 32-bit versions of uLisp this is a signed 32-bit number which will wrap around after about 25 days.

This is a lightweight replacement for the Arduino function tone. It generates a square wave on a digital pin; the following table shows which pin it uses for output on different boards:

The note number can be greater than 11 as an alternative way of representing notes in higher octaves. For example, the following function sca (scale) plays the scale of C on pin 3:

Modifies the value of place, which should be a list, to remove its first item, and returns that item. The second argument place can be one of the forms:

Prints its argument, using the pretty printer, to display it formatted in a structured way. It returns no value. For example, after defining the function var as follows:

Pretty-prints the definition of every function and variable you"ve defined in the uLisp workspace nicely formatted. The optional stream allows you to print the definitions to a stream, such as an SD card.

Prints its argument to a string, and returns the string. Characters and strings are printed with quotation marks and escape characters, in a format that will be suitable for read-from-string. For example:

Modifies the value of place, which should be a list, to add item onto the front of the list, and returns the new list. The second argument place can be one of the forms:

The function is currently only implemented on the AVR and ARM versions of uLisp, For examples see Programming AVR registers or Programming ARM registers.

Loads the definition of a function defined with defun, or a variable defined with defvar, from the Lisp Library. It returns t if it was loaded, or nil if the symbol is already defined, or if the symbol isn"t defined in the Lisp Library.

The function reverse is useful if you have been using cons to add elements onto the front of a list, but you want to return the list with the earliest elements at the front. For example, the following function log reads x values on analogue input A0 once a second, and returns the list of values:

The save-image command will return the size of the image, in objects. For example, since each object is four bytes, an ATmega328 with 1 Kbytes of EEPROM has room for an image containing 256 objects.

Modifies an existing list by setting the position in the list specified by place to the result of evaluating value. The second argument place can be one of the forms:

Replaces the cdr of the value of formwith value. This is particularly useful in conjunction with assoc, to change the value associated with a key in an association list. For example:

Replaces the nth value of the list form with value. This allows you to use a list of items as an array, accessed by the index of each item. The following example uses xyz as an array of coordinates in three dimensions:

Puts the processor into a low-power sleep mode for approximately the specified number of seconds. During sleep the current consumption typically drops to 50 µA on ATmega processors.

Sorts the list according to the test function, and returns the sorted list. Note that for efficiency the sort is destructive, meaning that the value of list may be changed by the operation.

Tracing a function prints out the call depth, and a list of the arguments each time the function is called, and the call depth and result each time the function returns.

Note that trace will not show calls to functions supplied as an argument to another function, such as apply, funcall, mapc, or mapcar, because in these cases only the body of the function is passed. For example:

The AVR version of uLisp uses my own I2C routines which don"t need a buffer, and don"t impose any limit on the length of transactions. The ARM, ESP, and MSP430 versions of uLisp use the Arduino Wire library, which imposes a 32-byte limit on each transaction.

The filename should be a string of up to 12 characters, consisting of a filename of up to 8 characters, a dot, and an extension of up to three characters.

If the file already exists Append writes to the end of the file without affecting the existing contents, whereas Overwrite deletes any existing content first.

The functions read, read-byte, and read-line can all be used to read from an SD card. If the end of the file has been reached, each of these functions returns nil.

Note that this description refers to uLisp 2.8 or later. For information about with-spi in earlier versions of uLisp see Reference for older versions.

stream: a variable that will be bound to an spi-stream. The variable should be specified in commands to read from and write to the stream within the form.

Ah, Arduino, I remember when you were just crawling around and blinking LEDs. Now you"re ready to learn how to speak! In this lesson we"ll learn how to use the Serial Library to communicate from the Arduino board back to the computer over the USB port. Then we"ll learn how to manipulate numbers and data.

For this lesson we won"t be using the shield, so simply remove it (keeping the mood light LEDs on it you"d like). The shield doesn"t contain any programs or data, it is just our way of connecing up the LEDs and resistors. We"ll use the shield again but for now, we can examine the RX and TX LEDs on the main Arduino board which will help you with debugging

Libraries are great places, and not yet illegal in the United States! If you ever need to learn how to do something, like say fix a motorcycle, you can go to your local library and take out a book. Sure you could buy the book but the library is nice because as a resource you can get the book whenever you need it, keeping your house uncluttered.

Software Librariesare very similar. We already studied what a procedureis, in lesson 3: a procedure is a list of things to do. A library is a big collection of procedures, where all the procedures are related! If you, say, want to control a motor, you may want to find a Motor Control Library: a collection of procedures that have already been written for you that you can use without having to do the dirty work of learning the nuances of motors.

Serial may sound like a tasty breakfast food, but its actually quite different. The word serialmeans "one after the other." For example, a serial killer doesn"t stop with one murder, but stabs many people one after the other. Serial data transfer is when we transfer data one bit at a time, one right after the other.

Information is passed back & forth between the computer and Arduino by, essentially, setting a pin high or low. Just like we used that technique to turn an LED on and off, we can also send data. One side sets the pin and the other reads it. It"s a little like Morse code, where you can use dits and dahs to send messages by telegram. In this case, instead of a long cable, its only a few feet.

(Now, people who are all geeked-out will probably get angry at this point because I"m simplifying things. Well guess what, its an Arduino tutorial, not a OSI Physical Network Architecture tutorial.)

The world isn"t run by weapons anymore, or energy, or money. It"s run by little ones and zeroes, little bits of data. It"s all just electrons. - Sneakers

Now is a good time to review how data is measured. For example, we measure weight with "ounces" and "pounds" (or grams and kilograms) and distances with "inches," "feet," and "miles" (or centimeters, meters and kilometers). Information has its own system of measurements:

An interesting thing to note is while 1000 grams is a kilogram, nearly all computer systems consider 1024 bytes to be a kilobyte. That is, a 1.0 Kilobyte file on your computer is 1024 bytes:

Hard drive makers are quite sneaky, you"ll notice that they define GB as being 1000 MB, and 1 MB = 1000 KB, etc. Given this fact, how many bytes can youreallystore in your 200GB drive?

We"ve actually used the Serial communications capability already quite a bit...that"s how we send sketches to the Arduino! When you Compile/Verify what you"re really doing is turning the sketch into binary data (ones and zeros). When you Upload it to the Arduino, the bits are shoved out one at a time through the USB cable to the Arduino where they are stored in the main chip.

Next time you upload a sketch, look carefully at the two LEDs near the USB connector, they"ll blink when data is being transmitted. One blinks when the Arduino is receiving data (RX) and one blinks when the Arduino is transmitting data (TX)

Enough chatting amongst ourselves, its time to get the Arduino talking. Our first sketch is going to be the hello world! program. When it starts up, it will say "hello world!"

Even if we have nothing in the setupor loop procedures, the Arduino requires them to be there. That way it knows you really mean to do nothing, as opposed to forgetting to include them!

We definately see that there is a Serial thing going on, and it looks like there is a procedure call as well. This is a library procedure call. The library is called Serial and inside the library is a procedure called begin.

If there"s no library name, it means that the procedure is in the "default" collection of procedures we use. For example, delay() is so common, the designers of the Arduino software didn"t bother putting it into a library.

So there"s some mystery procedure that"s called begin, well it"s not too tough to figure out what it might do. It"s the procedure that gets the Serial stuff ready. But what"s the 9600 about?

If you have broadband connection, you may remember reading somewhere that it has, say 350 kbps download rate. This is how fast the connection can read and write bits on the wire. (Needless to say, your broadband connection can transfer data a lot faster than an Arduino!)

This line also uses the Serial library, this time it"s calling a procedure called println which is just a shorthand for "print line". Note that the 6th letter in printlnis the letter L not the number 1. This time the input is a quotation, the line of text we would like it to print. We use two ""s (double quotes) to indicate the beginning and end of a line of text.

If the Arduino transfers data at 9600 bits per second and you"re sending 12 bytes of data, how long does it take to send over this information?Highlight the text below for the answer12 bytes of data equals 12 * 8 = 96 bits of data. If we can transfer 9600 bits per second, then 96 bits takes 1/100th of a second!

If the Arduino transfers data at 19200 bits per second (19200 baud) and you"re sending 12 bytes of data, how long does it take to send over this information?Highlight the text below for the answerThis is twice as fast as before, so it will take half the time, about 1/200th of a second.

It looks like not much is going on here. Somewhat disappointing since we had so much fun with blinking colored lights before. The trick here is that while you can see blinking lights quite easily, seeing serial data requires a monitor, which like your display monitor will show us what data is being transfered.

I"m not quite sure what the icon means, but regardless if you click that button you will replace the black Program Notification area with a Serial Monitor.

In the very common case of having a Diecimila Arduino, the serial monitor will auto-reset the Arduino. The sketch will start up a couple of seconds later

Otherwise, the Arduino does not reset itself. Either way, once you"ve switched to the serial monitor, press the reset button. If you have an NG Arduino you"ll have to wait 7 seconds for the sketch to start.

If you ever find that you"re getting a whole lot of gibberish instead of proper text, make sure that you have the correct baud rate selected in the drop down menu of the Serial Monitor. Note that this communication baud rate is indepedent of the upload process, which is fixed at 19200 bps.

Each time you reset the Arduino, it performs the setup procedure, and prints out Hello again. If you look closely at the Arduino, you will also see the little TX LED blink just as it prints out this message. That"s your indication that data was sent.

When you println you are sending data from the Arduino to the computer. The Send button (and the text input next to it) are used to send data to the Arduino. We aren"t going to be using it in this lesson so don"t be surprised that it doesn"t do anything when you click it!

Our next sketch will be a minor modification of this one. Instead of printing out Hello World just once, we"d like it to print it out over and over and over again.

What simple modification should we perform to make the Arduino print Hello World over and over again?Highlight the text below for the answer Simply move theSerial.println("Hello world!"); statement from the setup procedure to theloopprocedure.

Perform this modification and then compile and upload the new hyper-hello sketch. Then start up the serial monitor. You will see Hello World! scroll by super fast!

Now you should spend some time playing with println and making it display a message of your choice! Perhaps add some more println statements in order to make the message longer?

Note that we"re using 2 procedures here, the original println and now also print. The print procedure is just like println except it does not print out a "carriage return" at the end, starting a new line. You can experiment with changing the print"s to println"s and looking at the Serial Monitor output to verify this for yourself.

We"ve seen that if you use a quoted line of text as input to println procedure, it will display that text. In this case you can see that if you use a variable to println it will look up what that variable contains and print that out!

In this case, the Arduino looks at what the input to println is, and finds its actually a calculation. It looks up what a is (5) and what b is (10) and then adds them together (+) and then uses that as the value to send to println

Note that for now, we can only do math using integers, which if you recall, are whole numbers. That means we can"t yet print out numbers like 3.14 or 1.5.

I could go on and on about operators, its all very important stuff, but many people have written good tutorials on this topic already so I"m going to send you off to read them there!

Let"s make our first simple calculator, to calculate a hypoteneuse. If you remember from grade school, if you have a right-triangle, the hypoteneuse h can be calculated from the lengths of the two legs, c1 and c2 (which we"ll call a & b)

Which basically says "We"d like to use the math procedures, which are in a library that requires us to include the file math.h where the sqrtprocedure lives". Just ignore it for now, it"s not important.

It turns out that this is totally OK, it just means that we don"t know what his going to store yet, because we"re going to calculate it later. Since it"s not assigned to a value upon creation, the Arduino just creates the box, the stuff inside is whatever was in left over in memory.

In this line, we square a and b and then add them together, then we call the sqrt() procedure (which does exactly what you may think), to take the square root. Then we assign that to the variable h.

Lets say you have a variable "foo" which contains a number. You"d like to find the square root of the square root of this number. What line of code would print out this value?

You"ll create a Ohm"s law calculator. Ohm"s law says that Voltage = Current * Resistance. (This is a pretty useful law which forms the basis of electronics, and we"ll study it in depth more later.) Starting with two variables, i for current and rfor resistance, have it print out the amount of voltage that can be measured accross the resistor.

Let"s write a program that will do that hard drive size calculation we did before. We"ll start with the hard drive size in GB, and print out how many MB there are.

What"s happening is that we have an overflow problem. Think about your car odometer. The odometer has only 4 digits, it can display 0 miles to 9999 miles travelled. If you travel 10000 miles, the odometer will "roll over" to 0 again, and from then on it will display an incorrect value.

Keeping that in mind, remember in lesson 2 we said that when we define a variable we also define the box-type of the variable? The box is where we store the data, in this case the type is int. It turns out that an int type can store only 2 bytes.

To figure out how big a number we can store in a 2 byte-sized box use a calculator and take 2 to the power of the number of bits (since each bit can store 2 values, 0 or 1). Then we subtract 1 because like in the car odometer, you can"t actually display the final value, 10000. So, in this case the largest number is 216 - 1 = 65535. Since the number we"re trying to store (102400) is larger than that, we see that "rollover."

OK let"s fix it! All we need to do is change the variable type so that it can store more than 2 bytes of data. Here is a short list of types we can use.

How frustrating, we did the right thing and it still didn"t work. The problem we have now is although the boxes are the right size, we"re not handling them well.

If you look at this line, what"s happening here is that the Arduino looks up the value of the variable drive_gb to get 100. Then we multiply 100 by 1024 to get 102400 and put that in the drive_mb box. Except the way that the Arduino software does this is that it creates a temporary variable the same size as drive_gb to store that calculation result before it sticks it into drive_mb. So basically we are still getting an overflow, except now its happening as we do the calculation.

It turns out that I wasn"t completely honest in the previous section when I described all the different types. There"s another important fact to know, and that has to do with storing negative numbers.

We know that a variable that is 2 bytes large (16 bits) can store 216 different values. We assumed before that these values were 0 - 65535 inclusive. But then how do we store negative numbers? It turns out that there are two kinds of variables, signedand unsigned.

OK so you"re probably wondering: "This is such a pain, why bother with different size types? Lets just have every variable be as big as possible and we"ll never have roll-over problems."

Well, on your desktop computer, with gigabytes of memory (RAM), this is a reasonable thing to do. However, the tiny tiny computer in the Arduino has a grand total of 1 Kilobyte of memory. And some of that is used for background stuff you don"t see. For small sketches sure you can make everything a long and be done with it, but if you have a bigger sketch, you"ll run out of memory really fast and then you"ll have major problems. So in this case, every byte counts!

For example, lets say you have asigned int. If you have the value 32767 in that variable, and you add 1 to the variable, you"ll actually rollover to -32768.

Let"s say we have a variable that is byte type, it"s signed by default. It starts out with the value 127 and we add one to the variable, what will the new variable value be?

Write some sketches that will help you understand variable sizes, try creating variables of different types and signedness and adding and subtracting.

Although this lesson part seems quite boring, and severely lacking in blinky lights, understanding this stuff now will save you from a lot of headaches later when you have data overflows and your program is all wonky and you"re really frustrated because you can"t figure out why. (Trust me on this one!)

Now its time for you to expand the drive size calculator. Starting with the DriveCalcsketch, modify it so that it will also calculate how many KB are stored in the hard drive. Test it out with a couple different drive sizes.

Once you"ve got that working, modify it again so that it will also display how much space the drive actually holds thanks to the sneaky math-trick that manufacturers use. Have the sketch display how much storage space is "missing" (in KB) as well.

Good work, you got through one of the more boring lessons. In this lesson you learned how to print text and data to the Serial Monitor. This is essential for debugging future projects! You also learned about data types and storage and how to use the Arduino to calculate stuff.

Both PWM on pins 3 & 11, and tone(), use the Timer2 device. Only one of those can use Timer2 at a time, and they both want to use it in different ways, so there is a conflict between them.

Timer2 has nothing to do with SPI. So tone() has no effect on SPI, and nor does PWM have any effect on SPI (other than the fact that only one can come out of pin 11 at any time), since there is no internal resource conflict.

The first Arduino board based on an ARM processor. Features 2 channel 12-bit DAC, 84 MHz clock frequency, 32-bit architecture, 512 KB flash and 96 KB SRAM. Unlike most Arduino boards, it operates on 3.3 V and is not 5 V tolerant.

Arduino Yún is the combination of a classic Arduino Leonardo (based on the ATmega32U4 processor) with a Wi-Fi system on a chip (SoC) running Linino, a MIPS Linux based on OpenWrt.

This uses the same ATmega328 as late-model Duemilanove, but whereas the Duemilanove used an FTDI chip for USB, the Uno uses an ATmega16U2 (ATmega8U2 before rev3) programmed as a serial converter.

Total memory of 256 KB. Uses the ATmega16U2 (ATmega8U2 before Rev3) USB chip. Most shields that were designed for the Duemilanove, Diecimila, or Uno will fit, but a few shields will not fit because of interference with the extra pins.

Although the hardware and software designs are freely available under copyleft licenses, the developers have requested that the name "Arduino" be exclusive to the official product and not be used for derivative works without permission. The official policy document on the use of the Arduino name emphasizes that the project is open to incorporating work by others into the official product.

As a result of the protected naming conventions of the Arduino, a group of Arduino users forked the Arduino Diecimila, releasing an equivalent board called Freeduino. The name "Freeduino" is not trademarked and is free to use for any purpose.

The following boards are fully or almost fully compatible with both the Arduino hardware and software, including being able to accept "shield" daughterboards.

Seeeduino V4.2 is an Arduino-compatible board, which is based on ATmega328P MCU, Arduino UNO bootloader, and with an ATmega16U2 as a UART-to-USB converter. The three on-board Grove interface can make your board connect to over 300 Grove modules.

The Seeeduino Cortex-M0+ features an Atmel SAMD21 MCU which is based on a 32-bit ARM® Cortex®-M0+ processor. With the help of this powerful core, SAMD21 is much more powerful than AVR and can achieve many functions and more complex calculations that cannot be implemented on AVR chips.

SMART™ SAM D21 is a series of low-power microcontrollers using the 32-bit ARM® Cortex®-M0+ processor with 256 KB flash and 32 KB of SRAM. The Seeeduino Lotus Cortex-M0+ can be considered as a combination of Seeeduino and Base Shield.

LoRaWAN Class A/C Ultra long range communication Ultra low power consumption Arduino programming (based on Arduino Zero bootloader). Embedded with lithium battery management chip 4 Grove connectors onboard

LoRaWAN Class A/C Ultra long range of communication GPS communication Ultra low power consumption Arduino programming (based on Arduino Zero bootloader). Embedded with lithim battery management chip 4 Grove connectors onboard

Built around the ATmega32U4 chip Provide up to 20 Digital I/Os On board switch for 3. 3V and 5 V dual working mode 2 built-in Grove interface Built-in Micro USB for power supply and programming

Seeeduino Ethernet is a compact and multifunctional development platform, which merges data logging and processing, device control and Ethernet communication together into one

Built on Dragino Wi-Fi IoT module HE and ATmega32U4 Compatible with Arduino Yun Support 2.4 GHz Wi-Fi, 802.11 b/g/n Built-in Ethernet port and USB 2.0 Running OpenWrt system

Upgraded from Seeeduino Stalker V3.0 Lower power consumption (down to 100uA in sleep mode) Extra toggle switch for X-bee area 2 extra toggle switches for selecting the INT pin connected to RTC 3.3 V and 5 V dual mode

Serial communication on pin D0 (RX) and pin D1 (TX). used to receive (RX) and transmit (TX) TTL serial data. These pins are connected to the corresponding pins of the FTDI USB-to-TTL serial chip. By sliding the switch (S1), RX/TX pins can be re-routed to Bluetooth UART connector.

inviot U1 (arduino-compatible) all-in-one board with LCD, rotary encoder, RTC DS3231, EEPROM, buzzer, push buttons, RGB Led, NRF24 plug, and ESP8266 plug.Added features:

Japanese Arduino compatible kit using Uno board setting. Includes two mini-B USB sockets, 1602 LCD socket, 5 V or 3.3 V power selection, breadboard area.

Platino is an Arduino compatible board that supports 28-pin and 40-pin AVR devices. The board features multiple footprints for user interface elements like LCDs, pushbuttons, rotary encoders, LEDs and buzzer, supported by an extensive library. Bootloaders are available for all supported processors. On its backside are Arduino shield compatible connectors plus other extension connectors.

A low cost Arduino clone using the ATmega168/ATmega 328/ATmega 8 and designed for prototyping, it includes onboard peripherals such as an RGB LED, switches, IR LED, TSOP and LDR.

Minimalistic version of Arduino: small, without serial converter. Available as a kit, board only or assembled. Smaller than Arduino, with different footprint.

It has an improved automatic voltage selector, resolves problems during programming caused by shields that use the serial port, with an automatic serial port selector, and has the LM1117 voltage regulator.

Fully Arduino compatible board, that fits perfectly on a Raspberry Pi, and can be programmed through the Raspberry Pi"s serial interface. It also breaks out the Raspberry Pi"s SPI and I²C interfaces, or can be used as a stand-alone Arduino when powered with the external power header.

A low cost, high power, shield-compatible, complete Arduino-compatible board kit. Based on the Duemilanove, it comes with a 5 V / 1 A voltage regulator (optional 3.3 V regulator). Designed for low component count and for ease of assembly.

Includes 14 color-coded 3-pin connectors for direct cable connection of servos, electronic bricks, etc., and six color-coded3-pin connectors to analog inputs for electronic bricks, etc. Provides improved 3.3 V regulator supplying 500 mA, and optional 3.3 V operation. Switching regulator provides 5 V 2 A from up to 20 V external supply.

Includes 6 color-coded 3-pin connectors for direct cable connection of servos, electronic bricks, etc., and 6 3-pin connectors to analog inputs for electronic bricks, etc. Provides improved 3.3 V regulator supplying 500 mA, and optional 3.3 V operation.

A South African Arduino-compatible board derived from the Duemilanove, it features mostly through-hole construction except for the SMD FT232RL IC, power selection switches, option for a Phoenix power connector instead of DC jack, extra I/O pads for using Veroboard as shields. Designed for easy assembly in countries where exotic components are hard to find. PCB layout and board now available on Circuitmaker as Open Source Hardware

Can act as a host for an Android device and is compatible with the Android Open Accessory Development Kit, Micro SD card slot, D13 pin isolated with a MOSFET of which can also be used as an input.

Includes both 3.3 V and 5 V regulators for shields, D13 pin isolated with a MOSFET of which can also be used as an input. Can be connect to Arduino using CAT5 cable.

Arduino Due with onboard Ethernet, software-compatible with Arduino Ethernet shield, D13 pin isolated with a MOSFET of which can also be used as an input.

Uses Arduino Due form factor and largely compatible pin allocation. Runs at 5 V, but can be modified to run at 3.3 V. Triple-core, 32-bit, 200 MHz Aurix processor. 4 MB flash, 550 kB SRAM, 128 kB DataFlash. Optional CIC61508 safety monitor. Arduino IDE supported via add-in, plus Eclipse-based tools with multicore debugger.

MBZ Pro Mega is an Arduino compatible stand-alone board with a prototyping area and built-in Wi-Fi. Featuring a compact design, it helps to shrink Arduino projects and make it permanent.

Embed version of Mega 2560 CH340G/ATmega2560 - compatible with Arduino Mega 2560 board. Built on the Atmel ATmega2560 microcontroller and USB-UART interface chip CH340G.

The board used the chip CH340G as converter UART-USB. When working in the frequency 12 MHz, giving a stable result of data exchange (need install drivers to computer).

Compatible with Arduino shields and Pmod extension cards. ARM Cortex-A9 CPU (max frequency 667 MHz) and FPGA fabric, 512 Mb RAM, 8 Gb eMMC storage, on-board Wi-Fi and Bluetooth, USB 2.0 host.

Special purpose Arduino-compatible boards add additional hardware optimised for a specific application. It is kind of like having an Arduino and a shield on a single board. Some are Shield compatible, others are not.

Adds built-in CAN support through the AT90CAN128 micro processor, dual RJ45 jacks, and optional bus termination. Designed specifically for model railroading applications using the OpenLCB networking protocol, the hardware is sufficiently generic for use with other low-speed CAN networks. OUT OF BUSINESS 17 Dec 2014. All designs supposedly on GitHub, but Io:duino is not present. (https://web.archive.org/web/20160516101800/http://railstars.com/blog/)

This is a minimalist tracked platform based on the Arduino Duemilanove. Has an ATmega328 with Arduino bootloader, a dual H-bridge and additional prototyping space and headers. It is compatible with many shields, though four digital pins are used when operating the motor controller. Has an onboard voltage regulator, additional LEDs, a temperature sensor, and a light sensor. Part of the DFRobotShop Rover kit.

Open source Alternator Regulator suitable for 12 V to 48 V systems with many different battery chemistries (lead-acid, LiFeP04, etc.). Multi stage (3, 4), fully configurable. Features battery voltage and current measurement to assure complete and safe battery charging as well as CAN support for communications with other devices and status output (including "NMEA2000" like messages).

An Arduino-compatible board designed for inertial measurement and inertial navigation of aircraft, cars, and boats. It uses the ATmega128RFA1 and a variety of sensors IMU for various applications.

An Arduino Mega 2560 compatible board designed for auto-piloting and autonomous navigation of multirotor aircraft. Designed to be stacked with sensor bobs and boards with several breakout boards available.

Universal platform for wireless data transmission in the frequency band 868 MHz. The board combines features of Arduino Mini and the radio EZRadioPRO for receiving and transmitting data. With DataFlash.

WIOT is an Open Source, rechargeable, Li-Ion battery powered, Arduino compatible, development board designed around the ATmega32U4 processor and ESP8266 Wi-Fi Module.

FPGA-based drop-in replacement for Arduino UNO R3; offers faster clock rates and overall applications speed, higher-performance through vendor-supplied hardware-specific library functions utilizing FPGA; half of FPGA"s space remains available for further customizations including ones written by end user

iono is a general-purpose industrial controller based on Arduino, suitable for professional use (e.g. industrial automation, building automation). It features wide-range power supply, analog/digital inputs with robust protection circuits, power relays with double-winding latching bistable coils, 0÷10 V analog output, DIN rail case.

These boards are compatible with the Arduino software, but they do not accept standard shields. They have different connectors for power and I/O, such as a series of pins on the underside of the board for use with breadboards for prototyping, or more specific connectors. One of the important choices made by Arduino-compatible board designers is whether or not to include USB circuitry in the board. For many Arduino tasks, the USB circuitry is redundant once the device has been programmed, so that circuitry can be placed in the cable between development PC and board, thus making each instance of the board less expensive, potentially smaller, and more power efficient.

Seeeduino XIAO is the smallest Arduino compatible board in Seeeduino Family. It is an Arduino microcontroller that is embedded with the SAMD21 microchip. The interfaces of Seeeduino XIAO is rich enough in such a tiny Dev. Board as well.

Built around ATmega 2560 @ 16 MHz Massive GPIOs: 70 digital I/Os, 16 analog inputs and 4 UARTs, etc. Small form factor, 30% smaller than Arduino Mega 3.3 V and 5 V dual mode. Can be powered through a battery or through an AC to DC adaptor

A very power efficient breadboard friendly Arduino compatible board with onboard RFM69W/RFM69HW transceiver and a stock speed of 16 MHz @ 3.3 V. You can solder your own antenna or connect an antenna via U.FL connector.

BBFuino come with the ATmega328 controller, loaded with Optiboot (Arduino UNO"s bootloader), compatible with Arduino IDE and sample code, design to fit breadboard for prototyping and learning, lower down the cost by taking out the USB to UART IC, so the board has the basic component to operate.

The Crumbuino-Nano is a low-cost module comparable to the Arduino-Nano and can be used as Arduino-Nano in the Arduino-IDE. The Arduino bootloader is preloaded, hence the module is ready-to-use. The documentation shows the pin mapping of Arduino-naming to module pinout.

The Crumbuino-Mega is a low-cost module comparable to the Arduino-Mega 2560 and can be used as Arduino-Mega 2560 in the Arduino-IDE. The Arduino bootloader is preloaded, hence the module is ready-to-use. The documentation shows the pin mapping of Arduino-naming to module pinout.

A compact board with Molex connectors, aimed at environments where vibration could be an issue. DragonFly features the ATmega1280 and have all 86 I/O lines pinned out to connectors.

Freeduino USB Mega 2560, designed in India with Male headers (coming soon with Female Headers). Suitable for use in project, R&D, device and applicationsFreeduino USB Mega 2560 is a cost-effective and 100% pin and software compatible to the popular Arduino Mega 2560. Uses through hole components and has male headers.

Freeduino Lite v2 is a low cost, Freeduino with no USB and serial port. Needs FTDI USB Cable or FTDI Breakout board for programming. Uses through hole components and has male headers.

Freeduino nano designed in India, completely breadboard friendly, elegant and compact design.Freeduino Nano is a low cost Arduino Nano compatible board with mini USB connector using SMD components Freeduino Nano.

The world"s first wireless 3D position, inertia, and orientation beacon. Designed in the San Francisco bay area, this board provides a 10-DoF IMU with on-board ATmega32U4 chip (the same as the Arduino Leonardo).

A combination of an ATmega328P and an I²C based RGB backlit LCD interface (software compatible with the Adafruit RGB LCD shield), along with a USB serial programming interface done as a "backpack" module for the LCD.

The modified Arduino IDE allows the compiled user sketch to be uploaded onto the processor either with or without the proprietary GNSS software. NavSpark has 17 GPIO pins, which include two UARTs, 1 I²C, 1 SPI, 1 PWM, and a trigger. The first UART is usually used by the GNSS software to output NMEA 0183 data, although this can be disabled. This UART communicates over USB through a PL2303 serial converter and the transmit output is also made available on a pin. A 1 pulse per second signal is produced on a dedicated pin when a valid fix has been made.

There is a GPS-only version, a combined GPS/GLONASS version, and a GPS/Beidou version. An adaptor board adds a JST connector for a lithium-ion battery, a charger for the battery, and a microSD card slot connected to the SPI pins.

An Arduino-compatible board that includes a battery backed up real-time clock and a four channel DAC. Most Arduino-compatible boards require an additional shield for these resources.

Sanguino-compatible board that includes a battery backed up real-time clock and a two channel DAC. Sanguino"s feature the ATmega644P, which has additional memory, I/O lines and a second UART.

An Arduino Duemilanove compacted down to a breadboardable device (36 mm x 18 mm) that can be inserted into a standard 600 mil 28-pin socket, with USB capability, ATmega328P, and 6 onboard LEDs.

An Arduino-compatible board designed specifically for driving LEDs. It is generally used to drive an 8x8 RGB LED matrix using row scanning, but it can be used for other things.

A miniature Arduino compatible board with all of the digital and analog I/O pins brought out into a single line of pins (SIP). Available as a kit, intended for use with a solderless breadboard.

SODAQ, an Arduino Compatible Solar Powered sensor board The Raspberry Pi-sized SODAQ board is built for Solar Powered Data Acquisition. It is fitted with a Lipo charge controller and 12 Grove sockets for plug and play prototyping. It runs at 3.3 V and 8 MHz. It also comes with a DS3231 Real Time Clock and 16 Mbit serial flash for data logging. Its "bee" socket can use a range of different modules, like Xbee, RFbee, Bluetoothbee and GPRSbee to make the board communicate. The latest version has the powerful ATmega1284P microcontroller with 128 KB program space and 16 KB RAM and is still Arduino IDE compatible.

Arduino compatible board designed specifically for RF mesh network experiments. It features 10 I/Os, a 10-pin ISP programming connector, a connector for a standard LCD display (in 4 bit mode) and a connector for a 2.4 GHz RF module.

Arduino Mega compatible board designed specifically for robots requiring large numbers of servos. A built in 3 A switchmode power supply allows servos to plug directly into the board. Pin spacing allows making custom shields from standard prototype board.

Teensy++ 2.0 microcontrollerA slightly more powerful version of the Teensy 2.0. It has 46 I/O pins; 8 KB RAM; 128 KB of flash; 10-bit ADC; UART, SPI, I²C, I²S, Touch and other I/O capability.

A very small board based on the Freescale MK20DX128VLH5 CPU. It has 34 I/O pins; 16 KB RAM; 128 KB of flash; 16-bit ADC; 3xUARTs, SPI, I²C, I²S, Touch and other I/O capability. Version 3.0 is not recommended for new designs.

Same form factor as Teensy 3.0. Based on the Freescale MK20DX256VLH7 CPU. It has 34 I/O pins; 64 KB RAM; 256 KB of flash; 2x16-bit ADC; 12-bit DAC; 3xUARTs, SPI, 2xI²C, I²S, CAN bus, Touch and other I/O capability. All digital pins are 5 volt tolerant. Teensy 3.2 adds a more powerful 3.3 volt regulator, with the ability to directly power ESP8266 Wi-Fi, WIZ820io Ethernet and other power-hungry 3.3 V add-on boards.

Form factor compatible with Teensy 3.0/3.1/3.2, with more pins directly available. Based on the NXP/Freescale MK64FX512VMD12 CPU. It has 58 I/O pins; 256 KB RAM; 512 KB of flash; 27 analog inputs on 2x16-bit ADC; 2x12-bit DAC; 17 timers (20 PWM outputs); 6xUARTs, 3xSPI, 3xI²C, 2xI²S, CAN bus, On-board Micro SD Card, Touch and other I/O capability. All digital pins are 5 volt tolerant.

Form factor compatible with Teensy 3.0/3.1/3.2, with more pins directly available. Based on the NXP/Freescale MK66FX1M0VMD18 CPU. It has 58 I/O pins; 256 KB RAM; 1024 KB of flash; 25 analog inputs on 2x16-bit ADC; 2x12-bit DAC; 19 timers (2