Arduino Projects Archives - Tutorial45

Charlieplexing LEDs With The Arduino Board

Andreea — Tue, 27 Feb 2024 08:58:55 +0000

Charlieplexing LEDs With The Arduino Board

Adding LEDs to a project soon uses up valuable pins. What if you could control a row of 12 LEDs to show changing values with only 4 digital pins? There is a way and it is called Charlieplexing. It was first proposed in 1995 by Charlie Allen.

It relies on two properties that you may not have previously considered useful.

LEDs are Light Emitting Diodes and only pass electrical current in one direction. If you connect two of them together, in parallel but facing in opposite directions, you can use just 2 wires to control them.

If we connect the right-hand end of the circuit to 5V and the left-hand end to GND current will flow from right to left and the upper LED, #2, to light up and the lower LED will stay dark. If we reverse the connections, current will flow in the opposite direction and only the lower LED, #1, will be lit.

Here is the same setup on a breadboard. I’ve only used one resistor here, 660 Ohms, but it protects both LEDs. Notice that the long legs of the LEDs, the anodes, which are connected to the higher voltage, face in opposite directions.

Project #1 – 6 LEDs on 3 wires

If we want more than two LEDs we can add additional pairs of parallel, opposite facing LEDs in different arrangements. Let’s try 6 LEDs in three pairs in the form of a triangle. The blue circle represents a pair of opposed parallel LEDs.

Required materials

Arduino – an UNO works perfectly
LEDs – space constraints in project #2 make 3mm LEDs a better proposition
330 Ohm resistors
Breadboard or stripboard
Connecting wire

We can add the 330 Ohm resistors, the brown rectangles, to each of the corners, to limit the current, protect the LEDs and the Arduino pins. I’ve shown blue, yellow and green wires connected to the resistors.

BLUE	YELLOW	GREEN	LED ON
HIGH	LOW	?	0
LOW	HIGH	?	1
?	HIGH	LOW	2
?	LOW	HIGH	3
LOW	?	HIGH	4
HIGH	?	LOW	5

The question marks indicate that the wire is not connected. How can we effectively disconnect a wire while it is physically attached to an Arduino pin?

The second property that we seldom think about is that the digital microcontroller pins are tri-state. They can be set HIGH, LOW or used for INPUT. When a pin is set to INPUT MODE it is high impedance. So high that almost no current can flow so it is effectively disconnected.

This means we can control the 6 LEDs with three pins connected to the blue, yellow and green wires and replace the ‘?’ with INPUT mode rather than the OUTPUT mode used for HIGH and LOW.

Normally we just set a pin’s mode at the start of the script and leave it alone for the rest of the program. Here we need to keep switching modes and values.

Here is one way of coding the previous table:

// LED numbers    0,1,2,3,4,5
byte anodes[]  = {b,y,y,g,g,b};  // HIGH
byte caths[]   = {y,b,g,y,b,g};  // LOW
byte inputs[]  = {g,g,b,b,y,y};  // INPUT

b, y, and g are the wire colors, which have been allocated digital pin numbers. Reading vertically, for LED#0 to be switched ON – BLUE is set to HIGH (anode), YELLOW is set to LOW (cathode), and GREEN is set as an INPUT (disconnected).

The arrangement of LEDs in the previous diagram is logical but not very useful. It would be much more helpful if the LEDs were in a straight line. This is quite a tricky topological transformation to keep all the connections correct. What you gain is free pins involve more complicated wiring.

Here is the breadboard version:

Notice that all the LEDs face the same way with their anode, the longer leg, to the right. Each pair is cross-connected, anode to cathode, with the pink and black links. The blue and yellow wires drive the first pair, the second pair by the yellow and green wires, and the last pair by the green and blue wires. The colored wire is connected directly to the anode of the LED, and it needs to turn ON.

Above each LED is its number (0…5) and the wire colors, anode – cathode. This is quite an effort to link up, and the DuPont wires would probably get in the way when observing the flashing LEDs. Below is a photograph of a stripboard version, which, once soldered up, could easily be used in multiple projects. (There are no underside cuts of the copper strip on this board)

I connected the board to an Arduino UNO with the blue wire on pin 7, the yellow on pin 6, and the green on pin 5. I also added a 10 K Ohm potentiometer with the wiper on A0 and the outside connections to 5V and GND to give physical input to the program. You need to twist the pot knob once the LEDs stop flashing left to right.

// CharliePlexing 6 LEDs with multiplexed bar graph
// Tony Goodhew 27 June 2020

#define b 7   // Blue wire
#define y 6   // Yellow wire
#define g 5   // Green wire

#define potPin A0  // 10 K Ohm potentiometer on A0, 5V and GND
int done = false;
int wait = 190;
unsigned long startTime;

// LED numbers    0,1,2,3,4,5
byte anodes[]  = {b,y,y,g,g,b};  // HIGH
byte caths[]   = {y,b,g,y,b,g};  // LOW
byte inputs[]  = {g,g,b,b,y,y};  // INPUT

void show(int p){  // Turn on a single LED ( p = 0...5)
  pinMode(inputs[p], INPUT);   // Disconnect
  pinMode(caths[p], OUTPUT);
  digitalWrite(caths[p], 0);   // GND
  pinMode(anodes[p], OUTPUT);
  digitalWrite(anodes[p], 1);  // 5V
}

void show2(int q) {  // Multiple LEDs from left  
  for (int m = 0; m < q; m++)  {
    show(m);
    delay(3);
  }  
}

void setup() {
  Serial.begin(115200);  // Ready for de-bugging 
  startTime = millis(); 
}

void loop() {
  if (!done) {  // Basic left to right movement
    for (int m = 0; m < 10; m++){  // Cycles
      for (int i = 0; i <6; i++){  // LEDs 
        show(i);
        delay(wait);
        wait = wait - 3;           // Speed things up
      }
    }  
  }
  done = true;  // Finished with counted display
 
  // Twist the pot to change the LED lit up
  int potValue = analogRead(potPin); // Read potentiometer
  int pointer = potValue / 160; // values 0...6
  if (pointer == 0 ) {  // Turn off all LEDs
    pinMode(b, INPUT);  // Disconnect all wires
    pinMode(y, INPUT);
    pinMode(g, INPUT);
  }
  else{
    if (millis() - startTime < 17000) { // 17 seconds
      show(pointer - 1); // Single LED
    }
    else {
      show2(pointer);    // Bar graph
    }
  } 
}

The function show() does most of the work. It resets pin modes and values to switch on a single LED. It is called multiple times by the function show2(), which turns a row of LEDs ON/OFF so quickly that persistence of vision does not allow our eyes to notice the flashing and produces the appearance of a steady a bar graph, if slightly dimmed.

In the main loop there are three stages of display:

A single lit LED appears to move from left to right at faster and faster speeds.
A single LED is lit and its position in the row is controlled by the potentiometer.
A bar graph of lit LEDs is controlled by the potentiometer – 17 sec into the main loop.

Here is a second script that demonstrates generating patterns with this limited number of LEDs.

// CharliePlexing 6 LEDs Patterns
// Tony Goodhew 28 June 2020

#define b 7   // Blue wire
#define y 6   // Yellow wire
#define g 5   // Green wire

// LED numbers    0,1,2,3,4,5
byte anodes[]  = {b,y,y,g,g,b};
byte caths[]   = {y,b,g,y,b,g};
byte inputs[]  = {g,g,b,b,y,y};

void show(int p){  // Turn on a single LED ( p = 0...5)
  pinMode(inputs[p], INPUT);   // Disconnect
  pinMode(caths[p], OUTPUT);
  digitalWrite(caths[p], 0);   // GND
  pinMode(anodes[p], OUTPUT);
  digitalWrite(anodes[p], 1);  // 5V
}

void show2(int q) {  // Mulitple LEDs from left  
  for (int m = 0; m < q; m++)  {
    show(m);
    delay(3);
  }  
}

void setup() {
  Serial.begin(115200);  // Ready for de-bugging 
}

void loop() {
  // Opposites
  for (int m = 0; m < 7; m++){        // Cycles
    for (int i = 0; i <6; i++){       // Move up
      for (int t = 0; t <50; t++)  {  // Flashes 50 times
        show(i);                      // Left LED
        delay(3);                     // 3 millisecond flash
        show(5-i);                    // Right LED
        delay(3);
      } 
    }
  }
    
  // Pair
  for (int m = 0; m < 7; m++){         // Cycles
    for (int i = 0; i < 4; i++){       // Move up
      for (int t = 0; t <100; t++)  {  // Flashes
        show(i);                       // Left LED
        delay(3);
        show(i + 1);                   // Right LED
        delay(3);
      } 
    }
    for (int i = 0; i < 4; i++){      // Move down
     int ii = 4 - i;
     for (int t = 0; t <100; t++)  {  // Flashes 50 times
        show(ii);                     // Left LED
        delay(3);
        show(ii + 1);                 // Right LED
        delay(3);
      } 
    }
  }
}

Project #2 – 12 LEDs with 4 wires

We can arrange the 6 pairs of LEDs in a square with a resistor at each corner.

image

We can code this in a similar way to the previous script but we will need to set two lines as inputs.

// LED numbers    0,1,2,3,4,5,6,7,8,9,10,11
byte anodes[]  = {b,y,y,g,g,r,r,b,y,r, b, g};
byte caths[]   = {y,b,g,y,r,g,b,r,r,y, g, b};
byte input1[]  = {g,g,b,b,b,b,y,y,b,b, r ,r};
byte input2[]  = {r,r,r,r,y,y,g,g,g,g, y, y};

Here is a photograph of the stripboard version. The boards were 24 holes wide so there was just enough room to place twelve 3mm LEDs across the width of the board. (5mm LEDs are too wide, unfortunately, and need a single hole space between them).

Once again all the LEDs are facing the same way with the longer leg, anode, to the right. The copper strips on the underside of the board, underneath the resistors, are cut.

The board is well worth soldering up and keeping for use in other projects.

// CharliePlexing 12 LEDs
// Tony Goodhew 27 June 2020

#define b 7   // Blue wire
#define y 6   // Yellow wire
#define g 5   // Green wire
#define r 4   // red wire
#define potPin A0  // 10 K Ohm potentiometer on A0

// pin numbers    0,1,2,3,4,5,6,7,8,9,10,11
byte anodes[]  = {b,y,y,g,g,r,r,b,y,r, b, g};
byte caths[]   = {y,b,g,y,r,g,b,r,r,y, g, b};
byte input1[]  = {g,g,b,b,b,b,y,y,b,b, r, r};
byte input2[]  = {r,r,r,r,y,y,g,g,g,g, y, y};

void show(int p) {  // Turn on a single LED ( p = 0...5)
  pinMode(input1[p], INPUT);     // Disconnect
  pinMode(input2[p], INPUT);
  pinMode(caths[p], OUTPUT);
  digitalWrite(caths[p], 0);   // GND
  pinMode(anodes[p], OUTPUT);
  digitalWrite(anodes[p], 1);  // 5V
}

void show2(int p) {
  for (int m = 0; m < p; m++)  {
    show(m);
    delay(2);  // Reduced wait time to remove flicker
  }
}

void setup() {
  Serial.begin(115200);  // Ready for de-bugging  
}

void loop() {
  int potValue = analogRead(potPin); // Read potentiometer
  int pointer = potValue / 80; // values 0...12
  if (pointer == 0) {  
    pinMode(b, INPUT);  // Turn off all LEDs
    pinMode(y, INPUT);  // Disconnect all wires

    pinMode(g, INPUT);
    pinMode(r, INPUT);
  }
  else{
    show2(pointer);     // Bar graph display
  } 
}

This is just an update of the previous code to allow for the extra LEDs and save you typing. This is just the minimum to check wiring. Note that the time delay in the show2() loop has been reduced to remove flicker. Try 3 or 4 milliseconds to see the difference.

Things to try

Modify the code to extend the patterns supplied for the 6 LED board:

One LED moving left and right at speeds controlled by the potentiometer
2 or 3 LEDs moving together left and right or mirroring
Bar graph with input from a different sensor such as an ultrasonic distance sensor (SR04) or temperature sensor (TMP36 or DS18B20).
Wire up a compact 10 segment bar graph display and control it with 4 pins. I put an additional normal red LED at one end and a green LED at the other. If you try this remember to cut the tracks under the bar graph display. The display has cathodes on one side and anodes on the other with the LED between them. Using the resistors to make the connections is much quicker than stripping the insulation from wires. I suggest you test each LED as you build these boards, this is much easier than fault finding at the end.

Conclusion

I trust you enjoyed the topic and consider constructing one of the boards yourself. While we may save on the number of pins used to operate these boards, the complex nature of the wiring and code compensates for this. Our exploration does not have to conclude with 12 LEDs. The control capacity for the number of LEDs increases with every additional wire introduced, as per the formula

L = n(n-1)

where L is the maximum number of LEDs controlled and n the number of pins used.

Pins	2	3	4	5	6	7	8
LEDs	2	6	12	20	30	42	56

Another useful application would be on an interactive map or school project display with individual button switches on a menu lighting LEDs at different positions on the display. Examples include naming the features of an ancient castle or tourist attractions on a map of the local area.

Arduino to LCD projects – Using 3 Different Types of LCDs

Andreea — Tue, 27 Feb 2024 08:52:48 +0000

Arduino to LCD projects – Using 3 Different Types of LCDs

The Arduino IDE provides a serial monitor window which proves to be quite useful when it comes to printing values to debug a project. However, you can further enhance this functionality by attaching a small screen to your project that can provide feedback, display menus, and show results, improving its utility significantly. Moreover, this modification can also help to make your project completely portable.

I will be looking at three small and inexpensive LED screens that you can easily connect to your Arduino.

The Technology

These devices are Liquid Crystal Displays and have been around for some time. They do not emit light but block it. They may have a back-light or rely on reflected light.

Each display is made up of several layers and makes use of polarised light. If you polarise light horizontally with one filter you can cut off the light completely with a vertically polarised filter. Some liquids will twist the angle of polarisation when a voltage is applied to them allowing polarised light to pass through the filters.

They are called “twisted nematic liquid crystals”. If you sandwich such a crystal between two polarizers, crossed at 90°, the light would normally be blocked. If a voltage is applied to the crystal it ‘twists’ the light’s polarisation as it passes through the crystal and it is allowed through the second polarizing filter. A liquid crystal display is made up of many layers but remains very thin.

The one of the first uses of LCD displays was with electronic calculators in the early 1970s, replacing the previous tiny red 8 segment displays with magnifying lenses. These small monochrome devices were soon used in clocks, watches and other small, low power applications.

Advantages	Disadvantages
High contrast Low cost Low power Compact and very light	Often need an additional light source Fragile Slow to react Limited temperature range – avoid freezing

The Display Modules

I’m going to be looking at 3 different boards:

MakerHawk 12C OLED display with 128×64 pixels (blue)
MakerHawk 12C OLED display with 128×32 pixels (white)
AZ-Delivery HD44780 2004 Display with I2C converter (4 rows of 20 characters)

The first two can display graphic elements (lines, circles, pictures etc and text) while the last is a character only display.

MakerHawk OLED displays with SSD1306 driver chip

These are I2C devices and only need to be connected to 3.3V-5V, GND, SCL, and SDA. They are very small (diagonals are 0.96” and 0.91” respectively) lightweight, with tiny pixels and excellent contrast, making them very easy to read. The larger display is blue while the smaller is white.

They do not have a backlight and rely on reflection. The larger is supplied with 40 colored DuPont F-F cables and connection pins that need to be soldered to the board. You get two of the smaller displays in the packet, but no connection pins, sockets, or cables. There is no information supplied on how to connect them up to your Arduino or how to control them. The screens are protected with a plastic cover. (Take off carefully as the screens are delicate.) The four connections for I2C are clearly marked on the boards. Both devices have I2C addresses of 0x3C.

The next step is to solder on the pins or sockets and connect them up to your Arduino.

MakerHawk 12C OLED display with 128×64 (blue)

MakerHawk 12C OLED display with 128×32 pixels (white)

Project #1: Using Arduino with the LCD 128×64 pixel SSD1306 board

Materials needed:

Arduino – standard or cloned UNO
MakerHawk 12C OLED display with 128×64
Connecting wires
10K Ohm potentiometer

For these demonstrations the potentiometer will provide a variable input voltage on the A0 pin of the Arduino.

A4 is the SDA pin and A5 is the SCL pin on an Arduino UNO. Other boards may have different pins so check before you connect up. VCC goes to 5V and GND to GND. The wiper of the potentiometer goes to A0 on the Arduino and the other pins to 5V and GND.

Now we need to obtain suitable libraries for the SSD1306 boards and for the graphics routines. Adafruit has provided some very useful libraries which are easy to install on the current version of the Arduino IDE.

Start the Arduino software and use the Library Manager to search for and install the Adafruit SSD1306 library (2.2.1 at the time of writing). It covers both sizes of board and I2C and SPI versions. It also installs all the dependencies. Take the option to install the GFX library and the BusIO library at the same time. (https://github.com/adafruit/Adafruit_SSD1306)

Check at the bottom of the Examples Menu that all necessary libraries have been installed.

Notice that the library covers both sizes of screen as well as SPI and I2C protocols.

Now we are ready to see can see what the display can do. I’ve provided a couple of scripts to demonstrate the versatility of these displays. The first shows the graphical capabilities, without any user intervention via the potentiometer. I’ve included plenty of comments so you can see what is going on.

The screen origin is top left (0,0) with 128 horizontal pixels (0…127) moving right and 64 vertical pixels (0…63) moving down.

The screen may be small but it is very clear and sharp with enough room to be very useful.

/* SSD1306 128x64 I2C OLED display with Arduino UNO
 * Illustrates text elements and graphics
 * Tony Goodhew  3rd July 2020
 * Tutorial45.com
 */

#include <Wire.h>
#include <Adafruit_GFX.h>
#include <Adafruit_SSD1306.h>

#define SCREEN_WIDTH 128 // OLED display width, in pixels
#define SCREEN_HEIGHT 64 // OLED display height, in pixels

// Declaration for an SSD1306 display connected to I2C (SDA, SCL pins)
#define OLED_RESET     4 // Reset pin # (or -1 if sharing Arduino reset pin)
Adafruit_SSD1306 display(SCREEN_WIDTH, SCREEN_HEIGHT, &Wire, OLED_RESET);

void show() { // Often used sequence - Function to simplify code
  display.display();
  delay(2000);
  display.fillScreen(SSD1306_BLACK);
}
void show2() { // Faster
  display.display();
  delay(400);
  display.fillScreen(SSD1306_BLACK);
}
void setup() {
  Serial.begin(9600);
  randomSeed(analogRead(0));
  // SSD1306_SWITCHCAPVCC = generate display voltage from 3.3V internally
  if(!display.begin(SSD1306_SWITCHCAPVCC, 0x3C)) { // Old Address 0x3D for 128x64
    Serial.println(F("SSD1306 allocation failed"));
    for(;;); // Don't proceed, loop forever
  }
  
// Initialise some variables
  int cw = SSD1306_WHITE; // colour white
  int cb = SSD1306_BLACK; // colour black
  int wait = 2000; // 2 second delay
  int x0 = 7; // 3 pairs of co-ordinates
  int y0 = 7;
  int x1 = 123;
  int y1 = 23;
  int x2 = 50;
  int y2 = 61;
  int w = 117; // Width
  int h = 56;  // Height
  
// Draw a Title screen
  display.clearDisplay();
  display.setTextSize(2);              // Middle
  display.setTextColor(cw);
  display.setCursor(0,15);
  display.println("SSD1306");
  display.println("       GFX");
  display.setCursor(10,53);
  display.setTextSize(1);
  display.println("Tutorial45.com");
  display.display(); delay(wait);
  randomSeed(analogRead(1));
  display.fillScreen(cw);              // Fill screen WHITE
  display.setTextColor(cb);
  display.setCursor(40,53);
  display.println("Tutorial45.com");
  display.setTextColor(cw);
  display.display(); delay(wait); 
  display.fillScreen(cb);              // Fill screen BLACK
  display.display();
  
// Display some Pixels
  for (int m = 0; m <= 17; m++)  {     // 17 random pixels
    int xx = random(127);
    int yy = random(63);
    display.drawPixel(xx, yy, cw);
    display.display();
    delay(130);
  }
  delay(wait); 
  display.clearDisplay();
  
// Draw a Sine curve
  float sine[127]; 
// Initialise variables
  display.fillScreen(cb);
  display.setTextColor(cw);
  display.setCursor(10,56);
  display.setTextSize(1);
  display.println("Sine Curve");
  display.drawFastHLine(0, 32, 127 ,cw);
  for (int i = 0; i < 128; i++){
    sine[i] = (sin(radians(i *2.8125))) * -1; 
    display.drawPixel(i,int(sine[i]*25+32),cw);
    display.display();
  }
  show();

// Demonstrate basic shapes
  display.drawLine(x0, y0, x1, y1 + 30, cw);
  show2();
  display.drawFastVLine(50, 12, h, cw);  // Fast vertical line of length l
  show2();
  display.drawFastHLine(5, 45, w ,cw);   // Fast horizontal line of length w 
  show2();
  // Random lines
  for( int m = 0; m <10; m++) {
    int xr = random(127);
    int yr = random(63);
    int xl = random(127);
    int yl = random(63);
    display.drawLine(xr,yr,xl,yl,cw);
    display.display();
  }
  show();
  display.drawRect(x0, y0, w, h, cw);
  show2();
  display.fillRect(x0, y0, w, h, cw);
  show2();
  display.drawRoundRect(x0, y0, w, h, 14, cw);  // Rounded corners of radius 14  
  show2();
  display.fillRoundRect(x0, y0, w, h, 14, cw);
  show2();

// Grid
  for (int x =0; x < 130; x=x +10) {
    display.drawFastVLine(x, 0, 64, cw);
  display.display();
  }
  for (int y = 0; y < 64; y = y + 10) {
    display.drawFastHLine(0, y, 127 ,cw);
  display.display();
  }
  show();
    
// A few circles
  for (int r = 5;r <32; r=r+5){
    display.drawCircle(63, 31, r, cw);
    display.display();
    delay(500);
  }
  display.fillCircle(63, 31, 31, cw);
  show();
  display.drawTriangle(x0, y0, x1, y1, x2, y2, cw);
  show();
  display.fillTriangle(x0, y0, x1, y1, x2, y2, cw);
  show();

// Screen rotation - 4 0ptions 0, 90 180 and 270 degrees 
  display.clearDisplay();
  display.setCursor(25,32);   // Title splash
  display.print("Rotate Screen");
  display.display(); delay(wait);
  for (int rt = 0; rt <= 4; rt++){
    display.setRotation(rt % 4);               // Values 0..3
    display.clearDisplay();
    display.fillTriangle(0,0,0,30,30,0,cw);     // (x,y,x1,y1,x2,y2,colour)
    display.fillTriangle(0,15,40,50,15,0,cw);
    display.fillTriangle(15,0,50,40,0,15,cw);
    display.fillTriangle(40,50,50,40,20,20,cw);
    display.setTextSize(2);                     // Middle size
    display.setTextColor(cb); 
    display.setCursor(5,5);             
    display.println(rt % 4);
    display.display(); delay(wait);  
  }

// Text Sizes
  display.clearDisplay();
  display.setTextSize(1);                // Normal 1:1 pixel scale
  display.setTextColor(cw);   // Draw white text
  display.setCursor(0,0);                // Start at top-left corner
  display.println("Text Sizes");
  display.setTextSize(2);                // Medium
  display.println("SSD1306");
  display.setTextSize(3);                // Large - rather blocky  
  display.println("SSD1306");
  display.setTextSize(1);
  display.setCursor(40,53);
  display.println("Tutorial45.com");
  show();
  display.clearDisplay();

// Text along a path
  char msg[] =  "+++ Tutorial45.com +++";
  display.clearDisplay();
  for (int n = 0; n < 21; n++){
    char ch = msg[n];
    int p = n*6;
    float y1 = (sin(radians(p *2.8125)) * -1);
    int yy = int(y1 *25.0 + 32);
    display.drawChar(p, yy, ch, cw, cb, 1);
    display.display();
  }
  show();
  display.clearDisplay();
  char msg2[] = "SSD1306+Arduino=MAGIC";
  for (int n = 0; n < 21; n++){
    char ch = msg2[n];
    int p = n*6;
    float y1 = (cos(radians(p *2.8125)) * -1);
    int yy = int(y1 *25.0 + 32);
    display.drawChar(p, yy, ch, cw, cb, 1);
    display.display();
  }
  show();
  display.clearDisplay();
  char Msg[] = ".+Arduino+.";
  y2 = 50;
  for (int n = 0; n < 11; n++){
    char ch = Msg[n];
    int xx = n*12;
    display.drawChar(xx, y2, ch, cw, cb, 2); // (x,y,Char,foreGnd,backGnd,size)
    y2 = y2 - 5;  // Moving up the screen
    display.display();
  }
  show();
  
// Finish up
  display.setTextSize(1);             // Normal 1:1 pixel scale
  display.setTextColor(cw); 
  display.setCursor(0,25);
  display.setTextSize(2);             
  display.println("Finished");
  display.setCursor(40,53);
  display.setTextSize(1); 
  display.println("Tutorial45.com");
  display.display();
}
void loop() {
  // Empty - Linear program which halts
}

The most important thing to remember is that none of the changes specified by the script will actually appear on the screen until the instruction display.display() is executed. The changes go on in the background and this instruction forces updates to the display. In this script it is often hidden inside the show() routine.

The documentation for the library is found here: https://cdn-learn.adafruit.com/downloads/pdf/adafruit-gfx-graphics-library.pdf

Remember that these are simple monochrome displays so we only have two colours.

The second example demonstrates the user updating the display by changing the physical input. As the potentiometer is twisted some of the values displayed change and the bar graph changes in length.

/* SSD1306 128x64 I2C OLED display, Arduino UNO and 10K Ohm pot on A0
 * Tony Goodhew  3rd July 2020
 * Tutorial45.com
 */

#include <Wire.h>              
#include <Adafruit_GFX.h>
#include <Adafruit_SSD1306.h>

#define SCREEN_WIDTH 128 // OLED display width, in pixels
#define SCREEN_HEIGHT 64 // OLED display height, in pixels

// Declaration for an SSD1306 display connected to I2C (SDA, SCL pins)
#define OLED_RESET     4 // Reset pin # (or -1 if sharing Arduino reset pin)
Adafruit_SSD1306 display(SCREEN_WIDTH, SCREEN_HEIGHT, &Wire, OLED_RESET);

int sensorPin = A0;   // select the input pin for the potentiometer
int sensorValue = 0;  // variable to store the value coming from the sensor

void setup() {
  Serial.begin(9600);
  // SSD1306_SWITCHCAPVCC = generate display voltage from 3.3V internally
  if(!display.begin(SSD1306_SWITCHCAPVCC, 0x3C)) { // Address 0x3D for 128x64
    Serial.println(F("SSD1306 allocation failed"));
    for(;;); // Don't proceed, loop forever
  }
  display.clearDisplay();
  display.setTextSize(1);             // Small
  display.setTextColor(SSD1306_WHITE); 
  display.setCursor(0,0);             // Top Left corner
  display.println("SSD1306 Project");
  display.setCursor(20,10);
  display.println("Volts - Turn Pot");
  display.setCursor(64,118);
  display.setCursor(0,57);
  display.println("  Raw Pot    Volts");
  display.display();
}
// Functions for right alignment of integers
int iAlign2(int s){  // Space in 100s and 10s
  if (s < 100) {display.print(" ");}
    if (s < 10) {display.print(" ");}    
}
int iAlign3(int s){  // Space in 1000s
  if (s < 1000) {display.print(" ");}
  iAlign2(s);
}
int bar(int yy,int v) {
  display.drawLine(0,yy,0,yy+14, SSD1306_WHITE);
  display.fillRect(1,yy+2,127,10,SSD1306_BLACK);
  display.fillRect(0,yy+2,v,10, SSD1306_WHITE);
  display.setCursor(102,yy+2);
  iAlign2(v);
  display.print(v);
  display.println("%");
  display.display();
}
// ++++++++++++Main Loop ++++++++++++++
void loop() {
  // Read pot and display values
  sensorValue = analogRead(sensorPin); // Read the value from the sensor
  float volts = (sensorValue * 5.0 / 1023.0);  // Calculate voltage
  int x = float(sensorValue * 100.0/1018);     // Calculate percentage
  bar(20,x);  // Redraw bar graph
  display.fillRect(0, 40, 127, 15, SSD1306_BLACK); // Clear line
  display.setCursor(5,40);
  display.setTextSize(2);
  iAlign3(sensorValue);  
  display.println(sensorValue);  // Raw pot value
  display.setCursor(78,40);
  display.print(volts);          // Equivalent voltage
  display.setTextSize(1);
}

Notice that the whole screen is not updated. The top two lines and the bottom line are written in the setup() section. In the loop we update the bar graph and the 3 values. Flicker is minimal and caused by the ADC rather than the screen. The Raw Pot value has been right aligned by add spaces with the functions.

Project #2 Using the Arduino with the LCD SSD1306 128×32 pixel board

I’m now going to look at the smaller board. Obviously, it has half the screen size of the previous board, but this may have advantages if you only want to display a small amount of information or fit the display into a very confined space.

The connections are the same as on the previous display and properly labeled so just swap over the displays. This is a digital voltmeter using the potentiometer as input.

/* SSD1306 128x32 I2C OLED display, Arduino UNO and 10K Ohm pot on A0
 * Tony Goodhew  3rd July 2020
 * Tutorial45.com
 */

#include <Wire.h>              
#include <Adafruit_GFX.h>
#include <Adafruit_SSD1306.h>

#define SCREEN_WIDTH 128 // OLED display width, in pixels
#define SCREEN_HEIGHT 32 // OLED display height, in pixels

// Declaration for an SSD1306 display connected to I2C (SDA, SCL pins)
#define OLED_RESET     4 // Reset pin # (or -1 if sharing Arduino reset pin)
Adafruit_SSD1306 display(SCREEN_WIDTH, SCREEN_HEIGHT, &Wire, OLED_RESET);

int sensorPin = A0;   // select the input pin for the potentiometer
int sensorValue = 0;  // variable to store the value coming from the sensor

void setup() {
  Serial.begin(9600);
  // SSD1306_SWITCHCAPVCC = generate display voltage from 3.3V internally
  if(!display.begin(SSD1306_SWITCHCAPVCC, 0x3C)) { // Address 0x3D for 128x64
    Serial.println(F("SSD1306 allocation failed"));
    for(;;); // Don't proceed, loop forever
  }

// Title screen
  display.clearDisplay();
  display.setTextSize(2);             // Medium size
  display.setTextColor(SSD1306_WHITE);
  display.setCursor(5,5);
  display.println("Volt Meter");
  display.setCursor(40,24);
  display.setTextSize(1); 
  display.println("Tutorial45.com");
  display.display();
  delay(3000);
// Static part of screen
  display.clearDisplay();
  display.setTextSize(1);             // Small
  display.setTextColor(SSD1306_WHITE); 
  display.setCursor(0,0);             // Top Left corner
  display.println("Volts - Turn Pot");
}

int wedge(int v,float vv) {  // Wedge shaped bar graph - like Volume control
  display.drawLine(0,12,0,31, SSD1306_WHITE);
  display.fillRect(1,12,127,20,SSD1306_BLACK);
  display.fillTriangle(0,31,v,31,v,(31 - (19*v / 100)),SSD1306_WHITE);
  display.setCursor(102,20);
  display.print(vv);
  display.display();
}
// ++++++++++++Main Loop ++++++++++++++
void loop() {
  // Read pot and display values
  sensorValue = analogRead(sensorPin); // Read the value from the sensor
  float volts = (sensorValue * 5.0 / 1023.0);  // Calculate voltage
  int x = float(sensorValue * 100.0/1023);     // Calculate percentage
  wedge(x,volts);  // Redraw bar graph
  delay(100);      // Delay to reduce jitter  
}

There are two ways of overwriting text on the screen. Print the same text on top of the previous text in the background colour. This has the disadvantage of having to store the old value for reprinting. Alternatively, you can draw a background coloured filled rectangle over the text. I’ve used the latter in these examples.

Conclusion

These displays are inexpensive, very simple to connect up, use few Arduino pins and are easy to program. They are very clear and support a range of graphical elements. They may be a bit too small, especially the 128×32 board.

Suggested projects

Using a temperature sensor build a Current and Max-Min digital thermometer.

Using two temperature sensors and a humidity sensor build an Outside/Inside temperature & Humidity display.

Using a joystick as an input device (Horizonal plus vertical potentiometers and a button switch) with the larger screen build an ‘Etch-A-Sketch’ type game. The current position of the ‘pen’ could be shown by small dots on the four edges of the display and the button used to switch between foreground and background colours.

AZ-Delivery HD44780 2004 LCD Display Bundle 4×20

This beautifully packed product was supplied from Deggendorf, German. I bought it through Amazon UK which advertised, “The included E-Book provides useful information on how to begin your project, helps with a quick setup, and saves time on the configuration process.” I sent AZ an email requesting the E-Book and it arrived impressively quickly.

There was one small problem. The pdf describes how to use the bare display with its many connections but not how to use the I2C adaptor.

Luckily, I have used these before and know that you have to solder the interface board onto the display board. Normal practice is to solder it underneath with connection I2Cpins pointing out the side at the top left.

Alternatives:

Leave it off and use the board as outlined in the AZ guide – uses too many pins!
Solder on a row sockets; above or below the board so you can remove the backpack.
Solder a row of sockets with long legs so that you can use the display on a breadboard or put the adapter into the sockets.

Putting the interface board on the back has the advantage of gently tilting the display forward making it easier to read while working at your bench.

You will need a small screwdriver to adjust the setting of the blue trim-pot once the display is connected and running a script.

This is another I2C device so we connect up as before. Take care as the SCL and SDA pins are in a different order from the SSD1306! The I2C address of the backpack was 0x27.

There has been a great deal of chat on the various Arduino forums over the years about these backpack boards available from many manufacturers. They come with various I2C addresses but the many libraries available, often with the same name, do not make the address configurable and will only work with a specific board.

LCD 2004 Display	Arduino UNO
GND	GND
VCC	5V
SDA	A4
SCL	A5

Before we can run the script, we need to download a suitable library for this I2C version of the 2004 LCD. Unfortunately, AZ-Direct did not suggest a suitable site. I’ve been using the library at https://github.com/johnrickman/LiquidCrystal_I2C

and found that it works well with this interface board.

Once the library is installed, we are ready to try out the display.

Try this short script to test your connections:

/ LCD I2C 2004 Test
// Tony Goodhew 4th July 2020
// Tutorial45.com
#include <LiquidCrystal_I2C.h>
// https://github.com/johnrickman/LiquidCrystal_I2C
// Set LCD address to 0x27 with 20 chars by 4 lines display
LiquidCrystal_I2C lcd(0x27, 20, 4);  //(0x27, 16, 2) small LCD

// Character definitions - 5 cols x 7 rows
byte pi[8]  = {0,1,14,26,10,10,10};  // Compact version

byte smiley[8] = {                   // Easy but verbose version
  B00000,
  B01010,
  B00000,
  B00000,
  B10001,
  B01110,
  B00000,
};
byte sad[8] = {
  B00000,
  B01010,
  B00000,
  B00000,
  B01110,
  B10001,
  B00000,
};
void setup() {
  // Initialize the LCD
  lcd.init();
  // Create 3 new characters Max of 8 (0…7)
  lcd.createChar(0, pi);
  lcd.createChar(1, smiley);
  lcd.createChar(2, sad);
  
  // Set Cursor position and print text
  lcd.backlight();
  lcd.setCursor(3,0);
  lcd.print("Hello, world!");
  lcd.setCursor(3,1);
  lcd.print("Arduinos Rock");
  lcd.setCursor(0,2);
  lcd.print("Arduino LCD 2004 I2C");
  lcd.setCursor(3,3);
  lcd.print("Tutorial45.com");
  delay(2000);            //  Wait 2 seconds
  
  // print special characters to 4 corners of screen
  lcd.setCursor(0,3);
  lcd.write(0);
  lcd.setCursor(0,0);
  lcd.write(1);
  lcd.setCursor(19,0);
  lcd.write(2);
  lcd.setCursor(19,3);
  lcd.write(255);  // solid 5x8 block – built in
}

void loop(){}

You should be able to see clear, bright, white characters on a bright blue background. You will probably need to adjust the small blue trim-pot on the back-board to get the best contrast.

Once again, the origin is top left with the corner character at (0, 0). There are 20 characters on a line (0…19) and four rows (0…3).

We need to be very carful about running over the end of a line.

Change

lcd.print("Arduino LCD i2c 2004");

lcd.print("Arduino LCD i2c 2004xx*");

And change

lcd.print("Hello, world!");

lcd.print("Hello, world!123456");

When we run the script again, we find that line 0 overflows into line 2 and line 1 overflows onto the 3 line but the “*” gets immediately overwritten by the “T”.

This can cause some problems so take care not to overrun lines.

This script also demonstrates the definition of special characters. The user can define up to 8 characters on a 7 by 5 grid. This is easily carried out. Just look carefully at the happy and sad face definitions. The 1 bits indicate a white pixel.

byte pi[8]  = {0,1,14,26,10,10,10};

16	8	4	2	1
					0
				1	1
	1	1	1		14
1	1		1		26
	1		1		10
	1		1		10
	1		1		10

If you run the script again you will find these defined characters in the corners of the screen. The large block at the bottom right is predefined character 255. https://cdn-shop.adafruit.com/datasheets/TC2004A-01.pdf

This is a long but exciting document and shows the complete ‘built-in’ character set and how the characters you send to the screen are stored.

Here is a script to display all of the available characters.

// Display LCD 2004 character set
// Tony Goodhew 7th July 2020
// Tutorial45.com
#include <Wire.h>
#include <LiquidCrystal_I2C.h>
LiquidCrystal_I2C lcd(0x27,20,4);  // set the LCD address to 0x27 and 20x4

byte heart[8] = {0,10,31,31,14,4,0};
byte bknht[8] = {10,31,0,31,14,4,0};
byte ok[8] = {0,1,3,22,28,8,0};
byte no[8] = {0,27,14,4,14,27,0};
byte bong[8]  = {4,14,14,14,31,0,4}; 
byte music[8]  = {2,3,2,14,30,12,0};
byte clk[8] =  {0,14,21,29,17,14,0};
byte turn[8] = {1,1,5,9,31,8,4};

void setup(){
  lcd.init();  // initialize the lcd 
  lcd.backlight();
  lcd.createChar(1, heart);
  lcd.createChar(2, bknht);
  lcd.createChar(3, ok);
  lcd.createChar(4, no);
  lcd.createChar(5, bong);
  lcd.createChar(6, music);
  lcd.createChar(7, clk);
  lcd.createChar(0, turn);
  lcd.home();

// Show the character
  int n = 0;
  while (n < 255) {
    lcd.clear();
    lcd.setCursor(0,0);
    lcd.print("ASCII Codes: ");
    lcd.setCursor(4,1);
    lcd.print("Dec: ");
    lcd.print(n);
    lcd.print("-");
    lcd.print(n+15);
    lcd.setCursor(4,2);
    lcd.print("Hex: ");
    lcd.print(n, HEX);
    lcd.print("-");
    lcd.print(n+15, HEX);
    lcd.setCursor(2, 3);
    for (int m=0; m<16; m++) {
      lcd.write(n+m);
    }
    n = n + 16;
    delay(2000);
  }
 }
void loop() {}

Project #3 Using Arduino with the AZ-Delivery LCD 2004 and FC-113 I2C backpack

Materials needed

Arduino – standard or cloned UNO
AZ-Delivery LCD 2004 and FC-113 I2C backpack Connecting wires
3 x 10K Ohm potentiometer
1 x RGB LED or single Red, green and Blue resistors
3 x 560 Ohm resistors – nearby value
Breadboard or stripboard
Connecting wire

5) { lcd.write(0); // Happy face } else { lcd.write(1); // Sad face } }" style="color:#adbac7;display:none" aria-label="Copy" class="code-block-pro-copy-button">

// LCD I2C 2004 Project
// Tony Goodhew 4th July 2020
// LCD i2c, Arduino, RGB LED and 3 10K Ohm potentiometers
#include <LiquidCrystal_I2C.h>
// https://github.com/johnrickman/LiquidCrystal_I2C

// Set the LCD address to 0x27 & 20 chars by 2 lines display
LiquidCrystal_I2C lcd(0x27, 20, 4);  //(0x27, 16, 2) small LCD

#define r 6  // Red LED pin
#define g 5  // Green LED pin
#define b 3  // Blue LED pin

// Character definitions - 5 cols x 7 rows
byte smiley[8] = {
  B00000,
  B01010,
  B00000,
  B00000,
  B10001,
  B01110,
  B00000,
};
byte sad[8] = {
  B00000,
  B01010,
  B00000,
  B00000,
  B01110,
  B10001,
  B00000,
};
byte block[8]  = {0,31,31,31,31,31,31};

void align(int v){                // Right align number with spaces
  if (v < 100) {lcd.print(" ");}
  if (v < 10 ) {lcd.print(" ");}
}
void setup() {
  // Initialize the LCD
  lcd.init(); 
  // Create  new characters - Max of 8
  lcd.createChar(0, smiley);
  lcd.createChar(1, sad);
  lcd.createChar(2, block);  // For bar graph
  lcd.backlight(); 
  
  // Set up static Text
  lcd.clear();
  lcd.setCursor(6,3);
  lcd.print("Tutorial45.com"); // Banner
  delay(1500);
  lcd.setCursor(0,0);
  lcd.print("LCD 2004 I2C Project");
  lcd.setCursor(0,1);
  lcd.print("R:     G:     B:    ");  // Headings 
  lcd.setCursor(0,2);
  lcd.print("Power:            ");
}

void loop(){
  int rValue = analogRead(A0)/4;  // Get Red
  analogWrite(r, rValue);
  lcd.setCursor(2,1);
  align(rValue);
  lcd.print(rValue);  
  int gValue = analogRead(A1)/4;  // Get Green
  analogWrite(g, gValue);
  lcd.setCursor(9,1);
  align(gValue);
  lcd.print(gValue);
  int bValue = analogRead(A2)/4;  // Get Blue
  analogWrite(b, bValue);
  lcd.setCursor(16,1);
  align(bValue);
  lcd.print(bValue);
  int t = (rValue + gValue + bValue) *10 / 255 / 3; // Calc Power
  lcd.setCursor(6,2);
  lcd.print("          ");  // Clear bar graph
  lcd.setCursor(17,2);      // Display power number
  align(t);
  lcd.print(t);
  lcd.setCursor(6,2);
  for (int i=0; i<t; i++) {  // Bar graph
    lcd.write(2); 
  }
  lcd.setCursor(0,3); // Bottom left corner
  if (t > 5) {
    lcd.write(0);     // Happy face
  }
  else {
    lcd.write(1);     // Sad face
  }
}

Once again, we need to be careful when we overwrite. If you overwrite ‘100’ with ‘99’ you will get ‘990’. Always fill all of the character positions with new characters. It is easy to write 3 spaces, reset the cursor and write the number.

You can set the cursor to flash, but I’ve never found it useful.

After many days and e-mails back and forth with AZ-Delivery in Germany, I found that there is a separate E-book for the backpack board, called LCD16x2_FC-113.pdf – but it is only available in German.

It tells you to use the “New LiquidCrystal” library at: https://bitbucket.org/fmalpartida/new-liquidcrystal/downloads/

and provides this minimal script (adapted for 20 characters and 4 lines) to get you started:

AZ-Delivery.de<"); lcd.setCursor(0,1); lcd.print(">20x4 & FC-113!<"); } void loop() { lcd.setBacklight(HIGH); // blink the backlight delay(1000); lcd.setBacklight(LOW); delay(1000); }" style="color:#adbac7;display:none" aria-label="Copy" class="code-block-pro-copy-button">

// Uses the new-liquidcrystal_i2c library
// https://bitbucket.org/fmalpartida/new-liquidcrystal/downloads/
// This is the Test Script from AZ-Delivery matched with the 
// FC-113 Serial LCD Adapter Board Module I2C Interface

#include <Wire.h> 
#include <LCD.h>
#include <LiquidCrystal_I2C.h>

LiquidCrystal_I2C lcd(0x27,2,1,0,4,5,6,7,3,POSITIVE);  // Set the LCD I2C address

void setup()
{
  lcd.begin(20,4);
  lcd.clear();
  lcd.setCursor(0,0);
  lcd.print(">AZ-Delivery.de<");
  lcd.setCursor(0,1);
  lcd.print(">20x4 & FC-113!<");
}

void loop()
{
   lcd.setBacklight(HIGH);  // blink the backlight
   delay(1000);
   lcd.setBacklight(LOW);
   delay(1000);
}

Conclusion

This screen is large and much easier to read. Its update rate is quite slow. If you re-write the whole screen in one go, you can see a ripple across the display. The main drawback is that it cannot display graphical objects.

There is a slight problem with the documentation supplied to English-speaking customers by AZ-Delivery. However, the suppliers of the SSD1306 boards provided no help or documentation. Finding a suitable Arduino library that works properly could be a problem. The SSD1602 and 2004 LCDs are very popular with Arduino users and the I2C backpack does leave more pins free for your projects.

Project suggestions

Define some more characters.
Connect up some sensors and display the values received on the screen. You could use temperature, humidity, air pressure, distance, tilt, or accelerometer sensors.

Comparing the boards

	SSD1306 128×64	SSD1306 128×32	LCD 2004
Advantages	Excellent graphics3 sizes of charactersExcellent support libraryVery clear – high contrastOnly needs 2 pinsInexpensiveFree cables	Excellent graphics3 sizes of charactersExcellent support libraryVery clear – high contrastOnly needs 2 pins(2 in the packet)Cheap	Very easy to readLarge charactersEasy to see from a distanceOnly needs 2 pins with backpack
Disadvantages	A bit small	Probably too small	Cannot display graphicsFinding a suitable library

Overview

I’ve had the LCD 1602 and LCD2004 boards in my possession for quite a while now, acquiring them shortly after my initial Arduino purchase. Their utility has been significantly increased by the backpack. The larger SSD1306 board has been in use by me for approximately 18 months and I have found it to be exceedingly beneficial. The scope of what one can do with this small display is expansive. Which board to choose essentially comes down to ‘horses for courses’; it depends on the specifics of your project and the viewing distance required.

Nokia 5110 Arduino Project From Start to Hero

Andreea — Tue, 27 Feb 2024 08:46:36 +0000

Nokia 5110 Arduino Project From Start to Hero

The Philips PCD8544 driver chip is connected to a recycled screen from the popular Nokia 5110 phone. Because the screens are second-hand, the glass cover often has small scratches/blemishes.

They are rehoused in a metal box on a PCB with 8 connections. You need to solder on the supplied pins. The screen is a Liquid Crystal Display, LCD.

You can obtain a copy of the documentation for the driver chip from here and here.

AZ Delivery supply a free, 9-page pdf guide to using the device.

If we look more closely at the board, we find that the 8 connection pins are labeled on the bottom surface, and there appear to be 4 resistors near each of the LEDs, illuminating the screen from the sides.

The two sets of pads are interconnected so you can use either set. (Other suppliers of similar boards do not include resistors, which need to be added to the input line by the user. With these boards, you can control the brightness with a PWM pin supplying power to the LEDs. The connections on such boards may be in a different order – beware!)

There appear to be jumper pads (JP) linking something to GND, but the documentation has no information.

Important! This is a 3.3V device and will be damaged if connected directly to 5V.

Pin: Description	Additional information
1 RST (Reset )	Input
2 CE (Chip Enable)	Input
3 DC (Data/Control)	Input
4 DIN (Data in)	Input
5 CLK (Clock)	Input
6 VCC	Power supply – max. 3.3V!
7 LIGHT	LED active when connected to GND
8 GND (Ground)	Ground

The AZ Delivery documentation gives a Fritzing circuit showing the connections to an Arduino UNO using voltage shifters to protect the display.

This involves a great deal of wiring and extra expense for the voltage shifters.

A more compact and cheaper arrangement is to connect the data lines with 10K Ohm protection resistors as shown below. Make sure that VCC goes to the 3.3V outlet on the Arduino UNO.

The simplest solution would be to use a 3.3V Arduino microcontroller with direct connection.

Display Pin	Comment	UNO Pin
1 RST (Reset )	Input	3
2 CE (Chip Enable)	Input	4
3 DC (Data/Control)	Input	5
4 DIN (Data in)	Input	6
5 CLK (Clock)	Input	7
6 VCC	Max. 3.3V!	3.3V
7 LIGHT	To GND on breadboard	GND
8 GND (Ground)	Ground	GND

With the black link between pins 7 & 8 the LEDs are always on.

The documentation gives an example sketch to write pixels directly to the display using commands to the PCD8544. This is a pretty advanced method of driving the display and very a tedious method of creating images. You have to count pixels on graph paper and calculate the values of bytes.

// Control Nokia 5110 LCD Display
// AZDelivery Example script
#define CLK 7  // More convenient pins
#define DIN 6
#define DC 5
#define CE 4
#define RST 3
static const byte LOGOTBL[] = { //AZ Delivery Bitmap Logo
0x0F,0x5,0x5,0x0F,0x90,0xD0,0xB0,0x90,0x00,0x00,0x08,0x08,0x08,0x08,0x00,
0x00,0xFF,0x81,0x81,0x81,0x81,0x7E,0x00,
0xFF,0x89,0x89,0x81,0x81,0x81,0x00,0xFF,0x80,0x80,0x80,0x80,0x80,0x00,
0xFF,0x00,0x07,0x38,0xC0,0xC0,0x38,0x07,
0x00,0xFF,0x89,0x89,0x81,0x81,0x81,0x00,0xFF,0x09,0x19,0x29,0x49,0x86,
0x00,0xF,0x90,0x90,0x90,0x90,0xF7
};
// Functions
void LcdWriteCmd(byte order) { // Send command to display
  digitalWrite(DC, LOW); // DC Pin is LOW for commands to the display
  shiftOut(DIN, CLK, MSBFIRST, order); // Transmit data byte serially
  // with MSB (most significant byte) first
 }
void LcdWriteData(byte data) { // Send data to display
  digitalWrite(DC, HIGH); // DC Pin is HIGH for data to the display
  shiftOut(DIN, CLK, MSBFIRST, data); // Transmit data byte serial
  // with MSB (most significant byte) first
 }

void LcdWriteLogo() {
  digitalWrite(CE, LOW); // Chip Enable Pin is LOW,
  // data transfer is activated
  LcdWriteCmd(0x80); // Jump to row 0 column 0, Jump Column
  LcdWriteCmd(0x40); // Skip row

  // Clear screen completely
  for(int i=0; i < 504; i++) { 
  LcdWriteData(0x00); // Delete complete display
 }

  // Output AZ logo
  for(int i=0; i < 66; i++) {
  LcdWriteData(LOGOTBL[i]); // Write logo data into display
 }

  digitalWrite(CE, HIGH); // Chip Enable Pin is HIGH,
  // data transfer is deactivated
}

void setup() {
  pinMode(CLK, OUTPUT); // Switch pin to output
  pinMode(DIN, OUTPUT); // Switch pin to output
  pinMode(DC, OUTPUT); // Switch pin to output
  pinMode(CE, OUTPUT); // Switch pin to output
  pinMode(RST, OUTPUT); // Switch pin to output
  digitalWrite(RST, HIGH); // Reset signal to Nokia display
  delay(100);

  // forward
  digitalWrite(RST, LOW);
  delay(100);
  digitalWrite(RST, HIGH);
  delay(100);

  // Initialization of the display according to data sheet
  digitalWrite(CE, LOW); // Chip Enable Pin is LOW,
  // data transfer is activated
  LcdWriteCmd(0x21); // Extended command set LCD
  LcdWriteCmd(0x90); // set LCD Vop
  LcdWriteCmd(0x20); // Normal command LCD
  LcdWriteCmd(0x0C); // LCD Normal Mode
  digitalWrite(CE, HIGH); // Chip Enable Pin is HIGH,
  // data transfer is deactivated
}

void loop() {
  LcdWriteLogo();
  delay(20000);
}

On executing the script, I was pretty disappointed at this point as nothing appeared on the screen.

I looked in the datasheet and found that it was possible to change Vop (operational voltage?) and Bias.

I replaced

LcdWriteCmd(0x90); // set LCD Vop

With these 3 lines and ran the script again.

LcdWriteCmd(0xBF); // set LCD Vop
LcdWriteCmd(0x04); // Set Temp coefficient
LcdWriteCmd(0x13); // Bias mode 1:40

The expected display appeared.

The method works but we need to find an easier method of obtaining the bytes for a screen image. I decided to use Paint.net, to create the image, and LCDAssistant to convert a bitmap file to a list of bytes.

Starting with Paint.net (This could also be done using MS paint)

I defined a drawing area of 84 pixels wide and 48 pixels high. I disabled Antialiasing, added a star shape and some text to make a test piece. I saved the image as a bitmap with automatic depth.

I then loaded the saved image into LCDAssistant and used these settings.

I saved this to create another file called T45Test, which I then opened in Notepad.

I replaced the data block in the original script, and adjusted this loop to cope with the extra data and name change.

// Output Image
for(int i=0; i < 504; i++) { 
  LcdWriteData(T45Test[i]); // Write logo data into display
 }

This quickly produced the expected display.

What we need to be able to do now is write words, graphic elements and numbers to the screen in real-time under program control. Luckily there is an Adafruit library for this device to provide the necessary help.

This library is used with the Adafruit GFX library installed earlier on my computer for another project. Install any dependencies indicated as well. Try the long example script that comes with the library. It may well lack contrast initially.

The library handles contrast (Vop) and Bias slightly differently so I wrote a short script to allow investigation of the best settings to overcome the poor contrast.

// Set up screen visibility PCD8544 & Nokia 5110 screen
// Tony Goodhew 9th July 2020
// Tutorial45.com
#include <SPI.h>
#include <Adafruit_GFX.h>
#include <Adafruit_PCD8544.h>

//   PINS                                   CLK, DIN, DC, CE, RST
Adafruit_PCD8544 display = Adafruit_PCD8544(7,   6,   5,  4,  3);

void setup()   {
  Serial.begin(9600);
  display.begin(); // Initialise display
  int con = 56; // Change up or down by 1 to get
  int bias = 4; // the best settings for your display
  display.setBias(bias);
  display.setContrast(con);
  display.clearDisplay();  
  display.setCursor(0,5);  // INCLUDE ABOVE AT START OF YOUR OWN SCRIPTS
  display.println("Tutorial45.com");
  display.setCursor(0,15);
  display.print("Contrast: ");
  display.println(con);
  display.setCursor(0,25);
  display.print("Bias: ");  
  display.println(display.getBias());
  display.fillCircle(68, 36, 11, BLACK);
  display.fillCircle(68, 36, 6, WHITE);
  display.display();      // Essential instruction to update visible display
}
void loop() {}

Settings of con = 56 and bias = 4 gave the best contrast without activating the background (white) pixels on my display. Just try running the script with single unit changes to the values of con and bias until you get good visibility.

Now that the contrast has been fixed, we can see that the display has a slight aspect ratio ‘feature’ and circles appear as ellipses. The lower pixel count means that there is less space to write and draw when compared to other LCD displays – especially when compared with the SSD1306 128×64 display. However, the screen size and pixels are larger aiding visibility from a greater distance.

SSD1306 128×64 = 8192 pixels
SSD1306 128×32 = 4086 pixels
Nokia 86×48 = 4032 pixels

We are now ready to check how quickly the screen updates in a useful application. I added a 10K Ohm potentiometer on A0 to provide an input to the script. (You will need 2 potentiometers for a later script.)

// Volt Meter on Nokia 5110
// Tony Goodhew 9th July 2020
// Turorial45.com
// 10K Ohm potentiometer on A0
#include <SPI.h>
#include <Adafruit_GFX.h>
#include <Adafruit_PCD8544.h>

//   PINS                                   CLK, DIN, DC, CE, RST
Adafruit_PCD8544 display = Adafruit_PCD8544(7,   6,   5,  4,  3);

int sensorPin = A0;   // select the input pin for the potentiometer
int sensorValue = 0;  // variable to store the value coming from the sensor

void setup()   {
  Serial.begin(9600);
  display.begin();      // Initialise display
  int con = 56;         // Change up or down by 1 to get
  int bias = 4;         // the best settings for your display
  display.setBias(bias);
  display.setContrast(con);
  display.clearDisplay();
  display.setCursor(0,5);
  display.println("Tutorial45.com");
  display.setCursor(0,15);
  display.print("Volt Meter");
  display.setCursor(17,40);
  display.print("Volts:");
  display.display();  // Static parts of screen written at this point
}

int bar(int v, float vv) {  // Bar graph
  display.drawLine(0,28,0,40, BLACK);  
  display.fillRect(1,30,80,8,WHITE);   // Rub out old bar graph
  display.fillRect(0,30,v,8,BLACK);    // Write new bar graph
  display.fillRect(55,40,26,10,WHITE); // Rub out old text
  display.setCursor(55,40);
  display.print(vv);                   // Write new text
  display.display();                   // Update display
}
// ++++++++++++Main Loop ++++++++++++++
void loop() {
  // Read pot and display values
  sensorValue = analogRead(sensorPin); // Read the value from the sensor
  float volts = (sensorValue * 5.0 / 1023.0);  // Calculate voltage
  int x = float(sensorValue * 80.0/1023);     // Calculate percentage
  bar(x,volts);  // Redraw bar graph
  delay(100);      // Delay to reduce jitter 
}

Twisting the knob of the potentiometer changes the length of the bar and updates the voltage value. Notice the slight scratch marks on the bottom left corner of the bar graph.

Nokia 5110 Arduino Project with the AZ-Delivery with PCD8544 84×48 Pixel LCD Display

This project illustrates how the display can be changed under the control of a couple of 10K Ohm potentiometers. The potentiometers control the left/right and up/down position of a circular sight in which the player moves to cover the target, indicated by a small cross. As soon as the centers are identical the ‘target’ is destroyed and another target appears at a random position. There are 5 targets in a game. The search time is recorded and displayed at the end of the game.

// Game on Nokia 5110 – Search and Destroy
// Tony Goodhew 12th July 2020
// Turorial45.com
// 10K Ohm potentiometers on A0 and A1
#include <SPI.h>
#include <Adafruit_GFX.h>
#include <Adafruit_PCD8544.h>

//   PINS                                   CLK, DIN, DC, CE, RST
Adafruit_PCD8544 display = Adafruit_PCD8544(7,   6,   5,  4,  3);

int xPin = A0;   // x potentiometer
int yPin = A1;   // y potentiometer
int ox = 0;      // Old sight position - ring
int oy = 0;
int nx = 20;     // New sight position
int ny = 20;
int tx = 15;     // Target position
int ty = 15;
int count = 0;   // Targets destroyed
float t1 = 0;    // Time increment – for a single target
unsigned long t0;// millis() value when target appears
float total = 0; // Total time spent searching

void setup()   {
  Serial.begin(9600);      // Ready for debugging
  display.begin();         // Initialise display
  int con = 56;            // Change up or down by 1 at a time to get
  int bias = 4;            // the best settings for your display
  display.setBias(bias);
  display.setContrast(con);
  display.clearDisplay();
  display.setTextSize(2);  // Large text for Title screen
  display.setCursor(0, 0);
  display.print("Search");
  display.setCursor(0, 16);
  display.print("and");
  display.setCursor(0, 32);
  display.print("Destroy");
  display.display();
  delay(3000);
  display.setTextSize(1);  // Normal size text for game play
  display.clearDisplay();
}
int target(int x, int y, int c){   // Show target cross
  display.drawLine(x-2,y,x+2,y,c);
  display.drawLine(x,y-2,x,y+2,c);
}
int finish(){                  // Final screen to display total time
  display.clearDisplay();
  display.setTextSize(1);
  display.setCursor(5,5);
  display.print("You took:");
  display.setTextSize(2);
  display.setCursor(20,18);
  display.print(total);
  display.setTextSize(1);
  display.setCursor(0,40);
  display.print(count);
  display.setCursor(8,40);
  display.print(" Targets hit");
  display.display();
  while(1){}                     // Wait for ever - HALT
}
int ring(int x, int y, int c) {  // Draw a ring - sight
  display.drawCircle(x,y,3,c);   // Radius is 3 pixels
}
int blob(int x, int y, int c){   // Fill a ring - target destroyed
  display.fillCircle(x,y,3,c);
}
int flash(int x,int y){          // Flash location of destroyed target
  t1 = ((millis() - t0)/1000.0); // Incremental search time in seconds
  total = total + t1;            // Update total searching time
  randomSeed(int(t1*100.0));     // Improve randomness
  display.clearDisplay();
  display.display();
  display.setCursor(0,0);
  display.print(total);
  count = count + 1;             // Update targets destroyed
  display.setCursor(78,0);       // Show count - top right
  display.print(count);
  display.display();
  for (int i = 0; i<3; i++){     // Flash the blob - A hit!
    blob(x,y,1);
    display.display();
    delay(300);
    blob(x,y,0);
    display.display();
    delay(300);
  }
  t0 = millis();                 // Reset incremental timer
  if (count == 5){finish();}     // Enough targets destroyed?  
}
// ++++++++++++Main Loop ++++++++++++++
void loop() {
  target(tx,ty,1);                     // Show target
  nx = 3 + int(analogRead(xPin) /14);  // Get x position of sight
  ny = 43 - int(analogRead(yPin) /31); // Get y position of sight
  ring(ox,oy,0);                       // Blank old sight
  ring(nx,ny,1);                       // Show new sight
  ox = nx;                             // New position becomes old position
  oy = ny;
  display.display();
  if ((ox == tx) & (oy == ty)){ // Is it a hit?
    flash(tx,ty);               // Yes – Explode! Update time and targets hit
    tx = random(76) + 3;        // Get new random target position
    ty = random(33) + 10;
  }
}

Conclusion

This display operates at 3.3 volts, and it necessitates additional setup, such as voltage shifters or 10K resistors, particularly when used with 5-volt boards like the UNO.

Initially, I was not impressed with the limited documentation and the display’s low contrast, but now this device has grown on me. Although its pixel count is quite low, supporting only 6 brief lines of text, its display diagonal is larger than that of the SSD1306 128×64, making it more readable from afar.

It utilizes five data lines, in contrast to the two lines used by I2C devices. Notably, it has a speed sufficient for basic games and provides real-time feedback.

Additional things to try:

Exchange the simple potentiometer for an analog potentiometer joystick and see if this brings down your overall time with the game.
Use Paint.net and LCDAssistant to create a series of images to display one after another in a slide show.
Connect a distance sensor such as an HC-SR04 Ultrasonic or VL53L0X Time of Flight sensor and display the distance as you move your hand back and forth in front of the sensor.
Add an accelerometer and build a 2-dimensional ‘bubble-level’.

Hint

If your instructions are not appearing on the screen, check that you have ended the sequence with

display.display();

This is the essential instruction to force your changes to the screen and it is so easy to forget it.

Arduino Touch Screen Project

Andreea — Tue, 27 Feb 2024 08:16:01 +0000

Arduino Touch Screen Project

The AZ-Delivery 2.4” TFT LCD Touch Display boasts 320x 240 pixels with 16-bit color. It has Touch capabilities, a built-in SD card drive, and plugs straight onto the top of an Arduino UNO or Mega. Amazon charges less than £11 for this device. It offers a major step up from the tiny SSD1306 128×64 monochrome display.

The TFT screen is much larger than the SSD1306 128×64 and much more colourful. The package includes an SD card reader on the underside and a stylus for accurate touch-screen control.

AZ-Delivery usually supply an e-book (pdf document for download) with their boards. The German version comes first followed by other languages. This has just become available and provides setup instructions and a demonstration graphics only sketch.

The underside of the board has labels on the pins. As the board is an Arduino shield, it will only fit on a UNO in one position. The SD card reader sits between USB and the power socket. It will also plug into and Arduino MEGA 2560. J1 and J2 fit into the digital pins, covering D0 to D13, while J3 and J4 fit into the analog and power pins.

LCD_D0 to LCD_D7 provide an 8-bit bus with the other LCD pins on J3.

The card reader uses the SPI pins, D11, D12, and D13 with chip select on D10. (Not D4 as used in all the Arduino example sketches.)

This picture shows the underside of the board with an SD card inserted in the card reader.

I searched the Web for drivers and examples and found much praise for the TFT graphics, reports of problems with the Touch control, and nothing about the SD card reader on this board.

In the end, I installed several libraries (with all dependencies): Adafruit GFX, Adafruit TFT LCD, Adafruit TouchScreen, Adafruit ILI9341, MCUFRIEND_kbv, and SPFD5408-master. (The last 2 are not essential but include some interesting examples). The SD library is included in the basic Arduino set.

I’ve used GFX with mono displays such as SSD1306 and soon got the TFT display working. The following script gives some idea about what it can do. I’ve included pixels, text (of varying sizes), lines, rectangles, triangles, squares, graphs, screen rotation, and text on a path. I was very impressed with the clarity, speed, brightness, and colors produced.

Here is my first graphics sketch:

#include #define LCD_CS A3 // Chip Select goes to Analog 3 #define LCD_CD A2 // Command/Data goes to Analog 2 #define LCD_WR A1 // LCD Write goes to Analog 1 #define LCD_RD A0 // LCD Read goes to Analog 0 #define LCD_RESET A4 // Can alternately just connect to Arduino's reset pin // Colour definitions for 64k colour mode // Bits 0..4 -> Blue 0..4 // Bits 5..10 -> Green 0..5 // Bits 11..15 -> Red 0..4 #define BLACK 0x0000 #define WHITE 0xFFFF #define GREY 0x7BEF #define LT_GREY 0xC618 #define GREEN 0x07E0 #define LIME 0x87E0 #define BLUE 0x001F #define RED 0xF800 #define AQUA 0x5D1C #define YELLOW 0xFFE0 #define MAGENTA 0xF81F #define CYAN 0x07FF #define DK_CYAN 0x03EF #define ORANGE 0xFCA0 #define PINK 0xF97F #define BROWN 0x8200 #define VIOLET 0x9199 #define SILVER 0xA510 #define GOLD 0xA508 #define NAVY 0x000F #define MAROON 0x7800 #define PURPLE 0x780F #define OLIVE 0x7BE0 // Put colours in an array for random colour access int tftColours[] = {GREY,LT_GREY,GREEN,LIME,BLUE,RED,AQUA,YELLOW,MAGENTA,CYAN,DK_CYAN, ORANGE,PINK,BROWN,VIOLET,SILVER,GOLD,NAVY,MAROON,PURPLE,OLIVE, WHITE}; // Create the TFT object using all pin assignments Adafruit_TFTLCD tft(LCD_CS, LCD_CD, LCD_WR, LCD_RD, LCD_RESET); // =========== SETUP ================ void setup() { Serial.begin(9600); // Useful for debugging tft.reset(); tft.begin(0x9341); // SDFP5408 tft.setRotation(3); // 320 wide by 240 high - reset button on left tft.fillScreen(BLACK); tft.setCursor(30, 50); tft.setTextColor(RED); tft.setTextSize(3); tft.println("AZ-Delivery"); tft.setTextColor(YELLOW); tft.setCursor(30, 90); tft.println("2.4 TFT LCD"); tft.setCursor(30, 120); tft.println("Touch Display"); tft.setCursor(30, 150); tft.println("& SD Drive"); tft.setCursor(30, 200); tft.setTextColor(RED); tft.setTextSize(2); tft.println("Tutorial45.com"); delay(4000); tft.fillScreen(BLACK); // Clears the screen // Display some Pixels for (int m = 0; m <= 4000; m++) { // 4000 random pixels int xx = random(320); int yy = random(240); tft.drawPixel(xx, yy, tftColours[random(22)]); } delay(2000); tft.fillScreen(BLACK); int x = 1; int y = 50; int h = 50; int w = 50; int xj = 160; int yj = 170; int t = RED; // Quilt for (int xx=0; xx < 320; xx = xx + 32){ for (int yy = 0; yy < 240; yy = yy + 24){ tft.fillRect(xx,yy,32,24,tftColours[random(22)]); } } delay(2000); tft.fillScreen(BLACK); // Grid tft.fillScreen(BLACK); for (int x =0; x < 320; x=x +10) { tft.drawFastVLine(x+5, 0, 240, RED); } for (int y = 0; y < 240; y = y + 10) { tft.drawFastHLine(0, y+3, 320 , BLUE); } delay(2000); tft.fillScreen(BLACK); for (int x = 60; x < 200; x=x +25) { int yy = x-10; tft.drawRect(x,yy,40,45,tftColours[random(22)]); //drawRect( x, y, w, h, c) } delay(2000); // Rectangles tft.fillScreen(BLACK); for (int x = 60; x < 200; x=x +25) { int yy = x-10; tft.fillRect(x,yy,40,45,tftColours[random(22)]); //fillRect( x, y, w, h, c) } delay(2000); tft.fillScreen(BLACK); int r = 5; for (int x = 60; x < 200; x=x +25) { int yy = x-10; tft.drawRoundRect(x,yy,40,45,r,tftColours[random(22)]); r = r + 3; //drawRoundRect( x, y, w, h, r, c) } delay(2000); tft.fillScreen(BLACK); r = 5; for (int x = 60; x < 200; x=x +25) { int yy = x-10; tft.fillRoundRect(x,yy,40,45,r,tftColours[random(22)]); //fillRoundRect( x, y, w, h, r, c) r = r + 3; } delay(2000); // A few circles tft.fillScreen(BLACK); for (int r = 120;r > 5; r=r-10){ tft.fillCircle(80, 40, r, tftColours[random(22)]); delay(50); } for (int r = 5;r <120; r=r+10){ tft.fillCircle(random(200), random(120), r, tftColours[random(22)]); delay(50); } delay(2000); tft.fillScreen(BLACK); for (int r = 120;r > 5; r=r-10){ tft.drawCircle(80 + random(60), 40 + random(70), r, tftColours[random(22)]); } delay(1000); for (int r = 5;r <120; r=r+10){ tft.drawCircle(random(200), random(120), r, tftColours[random(22)]); } delay(2000); // Draw Sine and Cosine curves float sine[300]; float cosine[300]; tft.fillScreen(BLACK); tft.setTextColor(YELLOW); tft.setCursor(10,220); tft.setTextSize(2); tft.println("Sine Curve"); tft.setTextColor(RED); tft.setCursor(125,20); tft.println("Cosine Curve"); tft.drawFastHLine(9, 120, 300 ,BLUE); for (int i = 0; i < 300; i++){ sine[i] = (sin(radians(i *1.2))) * -1; tft.drawPixel(i+9,int(sine[i]*100+120),YELLOW); cosine[i] = (cos(radians(i *1.2))) * -1; tft.drawPixel(i+9,int(cosine[i]*100+120),RED); } delay(2000); // Screen rotation - 4 0ptions 0, 90 180 and 270 degrees tft.fillScreen(BLACK); tft.setCursor(25,32); // Title splash tft.print("Rotate Screen"); delay(1000); tft.fillScreen(BLACK); for (int rt = 0; rt <= 3 ; rt++){ tft.setRotation(rt % 4); // Values 0..3 tft.fillScreen(BLACK); int cw = WHITE; tft.fillTriangle(0,0,0,30,30,0,cw); // (x,y,x1,y1,x2,y2,colour) tft.fillTriangle(0,15,40,50,15,0,cw); tft.fillTriangle(15,0,50,40,0,15,cw); tft.fillTriangle(40,50,50,40,20,20,cw); tft.setTextSize(2); // Middle size tft.setTextColor(BLACK); tft.setCursor(5,5); tft.println(rt % 4); tft.setTextColor(RED); tft.setCursor(50,50); tft.setTextSize(3); tft.println("TFT LCD"); delay(1000); } tft.setRotation(3); tft.fillScreen(BLACK); // Text Sizes tft.setTextSize(1); // Normal 1:1 pixel scale tft.setTextColor(WHITE); // Draw white text tft.setCursor(0,0); // Start at top-left corner tft.println("Text Sizes\n"); tft.setTextSize(2); // Medium tft.println("AZ-Delivery\n"); tft.setTextSize(3); // Large - rather blocky tft.println("TFT LCD 320x240\n"); tft.setTextSize(4); // Larger - very blocky tft.println("Touch\n"); tft.setTextSize(5); // Largest - very blocky tft.println("2.4 inch"); tft.setTextSize(1); tft.setTextColor(BLUE); tft.setCursor(220,220); tft.println("Tutorial45.com"); delay(2000); // Text along a path tft.fillScreen(BLACK); char msg2[] = "+ TFT LCD+Arduino=MAGIC +"; for (int n = 0; n < 25; n++){ char ch = msg2[n]; int p = n*12; // was 9 float y1 = (cos(radians(p *2.8125)) * -1); int yy = int(y1 *25.0 + 100); tft.drawChar(p + 5, yy, ch, RED, BLACK, 2); } delay(4000); tft.fillScreen(BLACK); char msg[] = "+++ Tutorial45.com +++"; tft.fillScreen(BLACK); for (int n = 0; n < 22; n++){ char ch = msg[n]; int p = n*9; float y1 = (sin(radians(p *2.8125)) * -1); int yy = int(y1 *25.0 + 100); tft.drawChar(p + 60, yy, ch, GREEN, BLACK, 1); } tft.setTextSize(1); tft.setTextColor(BLUE); tft.setCursor(220,120); tft.println("Finished"); } // ------------ LOOP NOT NEEDED -------------------- void loop() {}" style="color:#adbac7;display:none" aria-label="Copy" class="code-block-pro-copy-button">

//  AZ-Delivery 2.4" TFT LCD touch shield Demo
//          Shield on Arduino UNO
//  +++ Tony Goodhew 17th September 2020 +++
//  Tutorial45.com

// Essential Adafruit GFX Libraries
#include <Adafruit_GFX.h>
#include <Adafruit_TFTLCD.h>

#define LCD_CS A3     // Chip Select goes to Analog 3
#define LCD_CD A2     // Command/Data goes to Analog 2
#define LCD_WR A1     // LCD Write goes to Analog 1
#define LCD_RD A0     // LCD Read goes to Analog 0
#define LCD_RESET A4  // Can alternately just connect to Arduino's reset pin

// Colour definitions for 64k colour mode
// Bits 0..4 ->   Blue 0..4
// Bits 5..10 ->  Green 0..5
// Bits 11..15 -> Red 0..4
#define BLACK 0x0000
#define WHITE 0xFFFF
#define GREY 0x7BEF
#define LT_GREY 0xC618
#define GREEN 0x07E0
#define LIME 0x87E0
#define BLUE 0x001F
#define RED 0xF800
#define AQUA 0x5D1C
#define YELLOW 0xFFE0
#define MAGENTA 0xF81F
#define CYAN 0x07FF
#define DK_CYAN 0x03EF
#define ORANGE 0xFCA0
#define PINK 0xF97F
#define BROWN 0x8200
#define VIOLET 0x9199
#define SILVER 0xA510
#define GOLD 0xA508
#define NAVY 0x000F
#define MAROON 0x7800
#define PURPLE 0x780F
#define OLIVE 0x7BE0
// Put colours in an array for random colour access
int tftColours[] = {GREY,LT_GREY,GREEN,LIME,BLUE,RED,AQUA,YELLOW,MAGENTA,CYAN,DK_CYAN,
                   ORANGE,PINK,BROWN,VIOLET,SILVER,GOLD,NAVY,MAROON,PURPLE,OLIVE, WHITE};

// Create the TFT object using all pin assignments
Adafruit_TFTLCD tft(LCD_CS, LCD_CD, LCD_WR, LCD_RD, LCD_RESET);

// =========== SETUP ================
void setup() {
  Serial.begin(9600); // Useful for debugging
  tft.reset();
  tft.begin(0x9341);  // SDFP5408
  tft.setRotation(3); // 320 wide by 240 high - reset button on left
  tft.fillScreen(BLACK);
  tft.setCursor(30, 50);
  tft.setTextColor(RED);
  tft.setTextSize(3);
  tft.println("AZ-Delivery");
  tft.setTextColor(YELLOW);
  tft.setCursor(30, 90);
  tft.println("2.4 TFT LCD");
  tft.setCursor(30, 120);
  tft.println("Touch Display");
  tft.setCursor(30, 150);
  tft.println("& SD Drive");
  tft.setCursor(30, 200);
  tft.setTextColor(RED);
  tft.setTextSize(2);
  tft.println("Tutorial45.com");
  delay(4000);
  tft.fillScreen(BLACK); // Clears the screen
  
  // Display some Pixels
  for (int m = 0; m <= 4000; m++)  {     // 4000 random pixels
    int xx = random(320);
    int yy = random(240);
    tft.drawPixel(xx, yy, tftColours[random(22)]);   
  }
  delay(2000);
  tft.fillScreen(BLACK);

  int x = 1;
  int y = 50;
  int h = 50;
  int w = 50;
  int xj = 160;
  int yj = 170;
  int t = RED;

  // Quilt
  for (int xx=0; xx < 320; xx = xx + 32){
    for (int yy = 0; yy < 240; yy = yy + 24){
      tft.fillRect(xx,yy,32,24,tftColours[random(22)]);
    }
  }

  delay(2000);
  tft.fillScreen(BLACK);
  // Grid
  tft.fillScreen(BLACK);
  for (int x =0; x < 320; x=x +10) {
    tft.drawFastVLine(x+5, 0, 240, RED);
  }
  for (int y = 0; y < 240; y = y + 10) {
    tft.drawFastHLine(0, y+3, 320 , BLUE);
  }
  delay(2000);
  tft.fillScreen(BLACK);
  for (int x = 60; x < 200; x=x +25) {
    int yy = x-10;
    tft.drawRect(x,yy,40,45,tftColours[random(22)]); 
    //drawRect( x,  y,  w,  h, c)
  }
  delay(2000);
  // Rectangles
  tft.fillScreen(BLACK);
  for (int x = 60; x < 200; x=x +25) {
    int yy = x-10;
    tft.fillRect(x,yy,40,45,tftColours[random(22)]); 
    //fillRect( x,  y,  w,  h, c)
  }
  delay(2000);
  tft.fillScreen(BLACK);
  int r = 5;
  for (int x = 60; x < 200; x=x +25) {
    int yy = x-10;
    tft.drawRoundRect(x,yy,40,45,r,tftColours[random(22)]);
    r = r + 3; 
    //drawRoundRect( x,  y,  w,  h, r, c)
  }
  delay(2000);
  tft.fillScreen(BLACK);
  r = 5;
  for (int x = 60; x < 200; x=x +25) {
    int yy = x-10;
    tft.fillRoundRect(x,yy,40,45,r,tftColours[random(22)]); 
    //fillRoundRect( x,  y,  w,  h, r, c)
    r = r + 3;
  }
  delay(2000);
  // A few circles
  tft.fillScreen(BLACK);
  for (int r = 120;r > 5; r=r-10){
    tft.fillCircle(80, 40, r, tftColours[random(22)]);
    delay(50);
  }
  for (int r = 5;r <120; r=r+10){
    tft.fillCircle(random(200), random(120), r, tftColours[random(22)]);
    delay(50);
  } 
  delay(2000);
  tft.fillScreen(BLACK);
  for (int r = 120;r > 5; r=r-10){
    tft.drawCircle(80 + random(60), 40 + random(70), r, tftColours[random(22)]);
  }
  delay(1000);
  for (int r = 5;r <120; r=r+10){
    tft.drawCircle(random(200), random(120), r, tftColours[random(22)]);
  } 
  delay(2000);
  
  // Draw Sine and Cosine curves  
  float sine[300];
  float cosine[300];
  tft.fillScreen(BLACK);
  tft.setTextColor(YELLOW);
  tft.setCursor(10,220);
  tft.setTextSize(2);
  tft.println("Sine Curve");
  tft.setTextColor(RED);
  tft.setCursor(125,20);
  tft.println("Cosine Curve");
  tft.drawFastHLine(9, 120, 300 ,BLUE);
  for (int i = 0; i < 300; i++){
    sine[i] = (sin(radians(i *1.2))) * -1; 
    tft.drawPixel(i+9,int(sine[i]*100+120),YELLOW);
    cosine[i] = (cos(radians(i *1.2))) * -1; 
    tft.drawPixel(i+9,int(cosine[i]*100+120),RED);
  }
  delay(2000);
  // Screen rotation - 4 0ptions 0, 90 180 and 270 degrees 
  tft.fillScreen(BLACK);
  tft.setCursor(25,32);   // Title splash
  tft.print("Rotate Screen");
  delay(1000);
  tft.fillScreen(BLACK);
  for (int rt = 0; rt <= 3  ; rt++){
    tft.setRotation(rt % 4);               // Values 0..3
    tft.fillScreen(BLACK);
    int cw = WHITE;
    tft.fillTriangle(0,0,0,30,30,0,cw);     // (x,y,x1,y1,x2,y2,colour)
    tft.fillTriangle(0,15,40,50,15,0,cw);
    tft.fillTriangle(15,0,50,40,0,15,cw);
    tft.fillTriangle(40,50,50,40,20,20,cw);
    tft.setTextSize(2);                     // Middle size
    tft.setTextColor(BLACK); 
    tft.setCursor(5,5);             
    tft.println(rt % 4);
    tft.setTextColor(RED);
    tft.setCursor(50,50);
    tft.setTextSize(3);
    tft.println("TFT LCD");
    delay(1000);  
  }
  tft.setRotation(3);
  tft.fillScreen(BLACK);
  // Text Sizes

  tft.setTextSize(1);                // Normal 1:1 pixel scale
  tft.setTextColor(WHITE);           // Draw white text
  tft.setCursor(0,0);                // Start at top-left corner
  tft.println("Text Sizes\n");
  tft.setTextSize(2);                // Medium
  tft.println("AZ-Delivery\n");
  tft.setTextSize(3);                // Large - rather blocky  
  tft.println("TFT LCD 320x240\n");
  tft.setTextSize(4);                // Larger - very blocky  
  tft.println("Touch\n");
  tft.setTextSize(5);                // Largest - very blocky  
  tft.println("2.4 inch");
  tft.setTextSize(1);
  tft.setTextColor(BLUE);
  tft.setCursor(220,220);
  tft.println("Tutorial45.com");
  delay(2000);
  
  // Text along a path
  tft.fillScreen(BLACK);
  char msg2[] = "+ TFT LCD+Arduino=MAGIC +";
  for (int n = 0; n < 25; n++){
    char ch = msg2[n];
    int p = n*12; // was 9
    float y1 = (cos(radians(p *2.8125)) * -1);
    int yy = int(y1 *25.0 + 100);
    tft.drawChar(p + 5, yy, ch, RED, BLACK, 2);
  }
  delay(4000);
  tft.fillScreen(BLACK);
  char msg[] =  "+++ Tutorial45.com +++";
  tft.fillScreen(BLACK);
  for (int n = 0; n < 22; n++){
    char ch = msg[n];
    int p = n*9;
    float y1 = (sin(radians(p *2.8125)) * -1);
    int yy = int(y1 *25.0 + 100);
    tft.drawChar(p + 60, yy, ch, GREEN, BLACK, 1);
  }
  tft.setTextSize(1);
  tft.setTextColor(BLUE);
  tft.setCursor(220,120);
  tft.println("Finished");
}

// ------------ LOOP NOT NEEDED --------------------

void loop() {}

Color picking

Normally, when setting the color of an RGB LED, you have a range of 0-255 (0-FF hex) for each RGB component, which gives white = F, red = FF000, green FF00, and blue = FF. This is a 24-bit color and takes 3 bytes. 224 gives 16,777,216 different colors. The TFT screen is a 16-bit color device that can display 65,536 colors – more than enough. Here, the range is limited to 5 bits each for red and blue and 6 for green. (Our eyes are more sensitive to green, so It gets the extra bit of accuracy.)

To convert a 24-bit colour to a 16-bit colour held in integers r, g and b, each with range 0 – 255.

// Convert 24-bit colours to 16-bit colours
// Tony Goodhew 22 Sept 2020
// Tutorial45.com
void setup() {
  Serial.begin(9600);
  int r = 255;
  int g = 255;
  int b = 255;
  unsigned int n = r/8 * 2048 + g/4 * 32 + b/8;
  Serial.println(n,HEX);
}
void loop() {}

The following sketch indicates the colors available by converting an array of 24-bit color values into their 16-bit equivalent and displaying them on the screen with the data. There are not enough pixels on the screen to display all the colors simultaneously, so the last part of the sketch takes out the least significant green bit and displays half the available colors in six ways.

#include #define LCD_CS A3 // Chip Select goes to Analog 3 #define LCD_CD A2 // Command/Data goes to Analog 2 #define LCD_WR A1 // LCD Write goes to Analog 1 #define LCD_RD A0 // LCD Read goes to Analog 0 #define LCD_RESET A4 // Can alternately just connect to Arduino's reset pin #define RED 0xF800 #define YELLOW 0xFFE0 #define BLUE 0x001F // Create the TFT object with all pin assignments Adafruit_TFTLCD tft(LCD_CS, LCD_CD, LCD_WR, LCD_RD, LCD_RESET); // =========== SETUP ================ int title(String s){ tft.fillScreen(0); // Clears the screen tft.setTextSize(3); tft.setCursor(60, 200); tft.setTextColor(0xC618); // Lt_Grey tft.println("32768 pixels"); tft.setCursor(120, 5); tft.println(s); } void setup() { Serial.begin(9600); // Useful for debugging tft.reset(); tft.begin(0x9341); // SDFP5408 - start the display tft.setRotation(3); // 320 wide by 240 high - reset button on left tft.fillScreen(0); // Clears the screen tft.setCursor(30, 50); tft.setTextColor(RED); tft.setTextSize(3); tft.println("AZ-Delivery"); tft.setTextColor(YELLOW); tft.setCursor(30, 90); tft.println("16-bit colours"); tft.setCursor(30, 120); tft.println("from"); tft.setCursor(30, 150); tft.println("24-bit colours"); tft.setTextColor(BLUE); tft.setCursor(30, 185); tft.setTextSize(2); tft.println("Tutorial45.com"); delay(4000); // A few interesting 24-bit colours - some dim - some bright! unsigned long c1[] = { 0x000000,0xFFFFFF,0x333333,0x666666,0x999999,0xCCCCCC,0xCCCC99,0x9999CC,0x666699, 0x660000,0x663300,0x996633,0x003300,0x003333,0x003399,0x000066,0x330066,0x660066, 0x990000,0x993300,0xCC9900,0x006600,0x336666,0x0033FF,0x000099,0x660099,0x990066, 0xCC0000,0xCC3300,0xFFCC00,0x009900,0x006666,0x0066FF,0x0000CC,0x663399,0xCC0099, 0xFF0000,0xFF3300,0xFFFF00,0x00CC00,0x009999,0x0099FF,0x0000FF,0x9900CC,0xFF0099, 0xCC3333,0xFF6600,0xFFFF33,0x00FF00,0x00CCCC,0x00CCFF,0x3366FF,0x9933FF,0xFF00FF, 0xFF6666,0xFF6633,0xFFFF66,0x66FF66,0x66CCCC,0x00FFFF,0x3399FF,0x9966FF,0xFF66FF, 0xFF9999,0xFF9966,0xFFFF99,0x99FF99,0x66FFCC,0x99FFFF,0x66CCFF,0x9999FF,0xFF99FF, 0xFFCCCC,0xFFCC99,0xFFFFCC,0xCCFFCC,0x99FFCC,0xCCFFFF,0x99CCFF,0xCCCCFF,0xFFCCFF}; unsigned int c2[80]; int l = 81; tft.fillScreen(0); // Clears the screen for (int i = 0; i < l; i++){ int r = c1[i] >> 16; // Get red 24-bit component - 0 to 255 int g = (c1[i] & 0x00ff00) >> 8; // Get green int b = (c1[i] & 0x0000ff); // Get blue unsigned long col2 = r/8 * 2048 + g/4 * 32 + b/8; // Create 16-bit value // int division removes least significant bits // multiplication shifts bits left tft.fillScreen(0); tft.fillRect(40,20,240,120,col2); tft.setTextSize(3); tft.setCursor(37, 145); tft.setTextColor(0xC618); // Lt_Grey tft.print("24-bit: "); tft.println(c1[i] & 0xFFFFFF,HEX); tft.println(" RGB: "+String(r) +" "+ String(g) +" "+String(b)); int col3 = col2 & 0xFFFF; c2[i] = col3; String q =String(c2[i], HEX); q.toUpperCase(); // String s = String(" 16-bit: "+String(c2[i], HEX)); String s = String(" 16-bit: "+q); tft.println(s); delay(800); } int x = 0; int y = 0; unsigned int c = 0; String s = "R G B"; title(s); for (int r = 0; r <32; r = r + 1){ for (int g = 0; g < 64; g=g+2){ for (int b = 0; b < 32; b = b + 1){ unsigned int c = r * 2048 + g * 32 + b; // Create 16-bit value tft.drawPixel(x +30, y+45, c); x = x + 1; if (x > 255){ x = 0; y = y + 1; } } } } delay(1000); s = "B G R"; title(s); x = 0; y = 0; for (int b = 0; b <32; b = b + 1){ for (int g = 0; g < 64; g = g + 2){ for (int r = 0; r < 32; r = r + 1){ unsigned int c = r * 2048 + g * 32 + b; // Create 16-bit value tft.drawPixel(x +30, y+45, c); x = x + 1; if (x > 255){ x = 0; y = y + 1; } } } } delay(1000); s = "G B R"; title(s); x = 0; y = 0; for (int g = 0; g < 64; g = g + 2){ for (int b = 0; b <32; b = b + 1){ for (int r = 0; r < 32; r = r + 1){ unsigned int c = r * 2048 + g * 32 + b; // Create 16-bit value tft.drawPixel(x +30, y+45, c); x = x + 1; if (x > 255){ x = 0; y = y + 1; } } } } delay(1000); s = "R B G"; title(s); x = 0; y = 0; for (int r = 0; r < 32; r = r + 1){ for (int b = 0; b <32; b = b + 1){ for (int g = 0; g < 64; g = g + 2){ unsigned int c = r * 2048 + g * 32 + b; // Create 16-bit value tft.drawPixel(x +30, y+45, c); x = x + 1; if (x > 255){ x = 0; y = y + 1; } } } } delay(1000); s = "B R G"; title(s); x = 0; y = 0; for (int b = 0; b <32; b = b + 1){ for (int r = 0; r < 32; r = r + 1){ for (int g = 0; g < 64; g = g + 2){ unsigned int c = r * 2048 + g * 32 + b; // Create 16-bit value tft.drawPixel(x +30, y+45, c); x = x + 1; if (x > 255){ x = 0; y = y + 1; } } } } delay(1000); s = "G R B"; title(s); x = 0; y = 0; for (int g = 0; g < 64; g = g + 2){ for (int r = 0; r < 32; r = r + 1){ for (int b = 0; b <32; b = b + 1){ unsigned int c = r * 2048 + g * 32 + b; // Create 16-bit value tft.drawPixel(x +30, y+45, c); x = x + 1; if (x > 255){ x = 0; y = y + 1; } } } } } void loop() {} //-- LOOP NOT NEEDED --" style="color:#adbac7;display:none" aria-label="Copy" class="code-block-pro-copy-button">

//  Almost all the colours - several ways
//  AZ-Delivery 2.4" TFT LCD touch shield Demo
//          Shield on Arduino UNO
//  +++ Tony Goodhew 25th September 2020 +++
//  Tutorial45.com

#include <Adafruit_GFX.h>
#include <Adafruit_TFTLCD.h>

#define LCD_CS A3     // Chip Select goes to Analog 3
#define LCD_CD A2     // Command/Data goes to Analog 2
#define LCD_WR A1     // LCD Write goes to Analog 1
#define LCD_RD A0     // LCD Read goes to Analog 0
#define LCD_RESET A4  // Can alternately just connect to Arduino's reset pin

#define RED 0xF800
#define YELLOW 0xFFE0
#define BLUE 0x001F
// Create the TFT object with all pin assignments
Adafruit_TFTLCD tft(LCD_CS, LCD_CD, LCD_WR, LCD_RD, LCD_RESET);

// =========== SETUP ================
int title(String s){
    tft.fillScreen(0); // Clears the screen
    tft.setTextSize(3);
    tft.setCursor(60, 200);
    tft.setTextColor(0xC618); // Lt_Grey
    tft.println("32768 pixels");
    tft.setCursor(120, 5);
    tft.println(s);   
  }
void setup() {
  Serial.begin(9600); // Useful for debugging
  tft.reset();
  tft.begin(0x9341);  // SDFP5408 - start the display
  tft.setRotation(3); // 320 wide by 240 high - reset button on left
  tft.fillScreen(0); // Clears the screen
  tft.setCursor(30, 50);
  tft.setTextColor(RED);
  tft.setTextSize(3);
  tft.println("AZ-Delivery");
  tft.setTextColor(YELLOW);
  tft.setCursor(30, 90);
  tft.println("16-bit colours");
  tft.setCursor(30, 120);
  tft.println("from");
  tft.setCursor(30, 150);
  tft.println("24-bit colours");
  tft.setTextColor(BLUE);
  tft.setCursor(30, 185);
  tft.setTextSize(2);
  tft.println("Tutorial45.com");
  delay(4000);
  // A few interesting 24-bit colours - some dim - some bright!
  unsigned long c1[] = {
        0x000000,0xFFFFFF,0x333333,0x666666,0x999999,0xCCCCCC,0xCCCC99,0x9999CC,0x666699,
        0x660000,0x663300,0x996633,0x003300,0x003333,0x003399,0x000066,0x330066,0x660066,
        0x990000,0x993300,0xCC9900,0x006600,0x336666,0x0033FF,0x000099,0x660099,0x990066,
        0xCC0000,0xCC3300,0xFFCC00,0x009900,0x006666,0x0066FF,0x0000CC,0x663399,0xCC0099,
        0xFF0000,0xFF3300,0xFFFF00,0x00CC00,0x009999,0x0099FF,0x0000FF,0x9900CC,0xFF0099,
        0xCC3333,0xFF6600,0xFFFF33,0x00FF00,0x00CCCC,0x00CCFF,0x3366FF,0x9933FF,0xFF00FF,
        0xFF6666,0xFF6633,0xFFFF66,0x66FF66,0x66CCCC,0x00FFFF,0x3399FF,0x9966FF,0xFF66FF,
        0xFF9999,0xFF9966,0xFFFF99,0x99FF99,0x66FFCC,0x99FFFF,0x66CCFF,0x9999FF,0xFF99FF,
        0xFFCCCC,0xFFCC99,0xFFFFCC,0xCCFFCC,0x99FFCC,0xCCFFFF,0x99CCFF,0xCCCCFF,0xFFCCFF};
  unsigned int c2[80];      
  
  int l = 81;
  tft.fillScreen(0); // Clears the screen
  for (int i = 0; i < l; i++){
    int r = c1[i] >> 16;              // Get red 24-bit component - 0 to 255  
    int g = (c1[i] & 0x00ff00) >> 8;  // Get green
    int b = (c1[i] & 0x0000ff);       // Get blue
    unsigned long col2 = r/8 * 2048 + g/4 * 32 + b/8;  // Create 16-bit value
    // int division removes least significant bits 
    // multiplication shifts bits left 
    tft.fillScreen(0);
    tft.fillRect(40,20,240,120,col2);
    tft.setTextSize(3);
    tft.setCursor(37, 145);
    tft.setTextColor(0xC618); // Lt_Grey
    tft.print("24-bit: ");   
    tft.println(c1[i] & 0xFFFFFF,HEX);
    tft.println(" RGB: "+String(r) +" "+ String(g) +" "+String(b));
    int col3 = col2 & 0xFFFF;
    c2[i] = col3;
    String q =String(c2[i], HEX);
    q.toUpperCase();
//    String s = String("   16-bit: "+String(c2[i], HEX));
    String s = String("   16-bit: "+q);
    tft.println(s);
    delay(800);
  }
  int x = 0;
  int y = 0;
  unsigned int c = 0;
  String s = "R G B";
  title(s); 
  for (int r = 0; r <32; r = r + 1){
    for (int g = 0; g < 64; g=g+2){
      for (int b = 0; b < 32; b = b + 1){
        unsigned int c = r * 2048 + g * 32 + b;  // Create 16-bit value
        tft.drawPixel(x +30, y+45, c);
        x = x + 1;
          if (x > 255){
            x = 0;
            y = y + 1; } } } }
  delay(1000);
  s = "B G R";
  title(s);
  x = 0; y = 0;    
  for (int b = 0; b <32; b = b + 1){
    for (int g = 0; g < 64; g = g + 2){
      for (int r = 0; r < 32; r = r + 1){
        unsigned int c = r * 2048 + g * 32 + b;  // Create 16-bit value
        tft.drawPixel(x +30, y+45, c);
        x = x + 1;
          if (x > 255){
            x = 0;
            y = y + 1; } } } }
  delay(1000);
  s = "G B R";
  title(s);
  x = 0; y = 0; 
  for (int g = 0; g < 64; g = g + 2){    
    for (int b = 0; b <32; b = b + 1){ 
      for (int r = 0; r < 32; r = r + 1){
        unsigned int c = r * 2048 + g * 32 + b;  // Create 16-bit value
        tft.drawPixel(x +30, y+45, c);
        x = x + 1;
          if (x > 255){
            x = 0;
            y = y + 1; } } } }
  delay(1000);
  s = "R B G";
  title(s);
  x = 0; y = 0;
  for (int r = 0; r < 32; r = r + 1){    
    for (int b = 0; b <32; b = b + 1){ 
      for (int g = 0; g < 64; g = g + 2){
        unsigned int c = r * 2048 + g * 32 + b;  // Create 16-bit value
        tft.drawPixel(x +30, y+45, c);
        x = x + 1;
          if (x > 255){
            x = 0;
            y = y + 1; } } } }
  delay(1000);
  s = "B R G";
  title(s);
  x = 0; y = 0; 
  for (int b = 0; b <32; b = b + 1){
     for (int r = 0; r < 32; r = r + 1){
        for (int g = 0; g < 64; g = g + 2){ 
        unsigned int c = r * 2048 + g * 32 + b;  // Create 16-bit value
        tft.drawPixel(x +30, y+45, c);
        x = x + 1;
          if (x > 255){
            x = 0;
            y = y + 1; } } } }
  delay(1000);
  s = "G R B";
  title(s);
  x = 0; y = 0;
  for (int g = 0; g < 64; g = g + 2){
    for (int r = 0; r < 32; r = r + 1){ 
      for (int b = 0; b <32; b = b + 1){
        unsigned int c = r * 2048 + g * 32 + b;  // Create 16-bit value
        tft.drawPixel(x +30, y+45, c);
        x = x + 1;
          if (x > 255){
            x = 0;
            y = y + 1; } } } }
}   
void loop() {} //-- LOOP NOT NEEDED --

Using the SD card reader

Looking at the bottom of the board there are 4 pins used for communication with the SD card reader:

SD_SS pin 10-SS = Chip Select
SD_DI pin 11- MOSI
SD_DO pin 12-MISO
SD_SCK pin 13-CLOCK

This is a standard SD card reader and uses the SPI pins on the UNO and pin 10 as the Chip Select.

The Arduino.cc site lists the following SPI pins on their different boards

Arduino / Genuino Board	MOSI	MISO	SCK	SS (slave)	SS (master)	Level
Uno or Duemilanove	11 or ICSP-4	12 or ICSP-1	13 or ICSP-3	10	–	5V
Mega1280 or Mega2560	51 or ICSP-4	50 or ICSP-1	52 or ICSP-3	53	–	5V
Leonardo	ICSP-4	ICSP-1	ICSP-3	–	–	5V

If you need to use the SD card with a MEGA you will need to run the board via jumper leads.

The SD card reader library is included with the basic setup, so we do not need to load a fresh library. The examples cover the simple tasks of creating, writing to, reading from and deleting files at a very basic level, all with strings.

I used a 16GB SD-HC class 4 card. It is easy to insert into the reader with a gentle push. Push in again to extract if necessary.

To check that everything is in order you can run the “CardInfo” sketch from the Examples tab of the File muenu. (File =>> Examples =>> SD =>> CardInfo.) Make sure you set:

const int chipSelect = 10;

on the line before the setup routine. I got the following with my card, which I had been using earlier.

At this point it is worth running the other example sketches to get a feel for how the card reader works.

You may have noticed that:

This is a very basic serial file device.
You can only have one file open at a time.
You write strings to the file (so numbers have to be converted to strings before they are saved.)
You can make up a record of several strings which are in turn made up of characters.
You concatenate the sub-strings to make the record string using a comma as a delimiter.
Each line in the file is a record which terminates with “\n”.
If you write to an existing file the new data is appended at the end.
In the examples the chip select pin is 4. We have to use pin 10 when the shield is plugged into an UNO.

An obvious use for the SD reader is to log readings from sensors and display the results on the TFT display. Unfortunately, the shield covers and uses most of the pins. The solution is to connect just the SD reader and power pins with jump leads which leaves plenty of pins to collect data from sensors.

Most Arduino users seldom use string manipulation. The documentation and a few simple examples of how to use strings are well scattered over the Web and difficult to find. The first sketch demonstrates how to create a file of 5 records/lines, each made up from an integer, a string, and a floating-point variable. The file is called datalog6.txt.

// Create a log file sketch
// Write demo log file: 'datalog6.txt' with 3 fields per
//      record: Int, String and Float
// The SD_Read_File sketch can process it.
// Tony Goodhew 21 Sept 2020
// SD reader on TFT shield – Output to Serial Monitor
// Tutorial45.com
#include <SPI.h>
#include <SD.h>
const int chipSelect = 10;
void setup() {
  // Open serial communications and wait for port to open:
  Serial.begin(9600);{}
  Serial.print("Initializing SD card...");
// see if the card is present and can be initialized:
  if (!SD.begin(chipSelect)) {
    Serial.println("Card failed, or not present");
    // Halt
    while (1);
  }
  Serial.println("card initialized.");
  File dataFile = SD.open("datalog6.txt", FILE_WRITE);
  // Set up test data in 3 arrays
  int i[] = {1, 2222, 3, -4, 5};
  String s[] = {"Tony", "Fred", "Anne", "Mags", "William"};
  float f[] = {3.14, 2.2, 3.3333, 10.66, -5.5};
  String j = "";  // record string
  Serial.println("Writing datalog6.txt");
  // Loop for 5 data records
  for (int p=0; p < 5; p++){
    // Pack the data up into a string, j
    // Build long string with 3 data items as strings
    //    separated with commas
    j = String(i[p]) + "," + s[p]+ "," + String(f[p]); // One record
    // Display the long string
    Serial.println(j);
    // Save j to SD Card
    // if the file is available, write to it:
    if (dataFile) {
      dataFile.println(j);  // Write j to the file
    }
    // if the file isn't open, pop up an error:
    else {
    Serial.println("error opening datalog6.txt");
    }
  }
  dataFile.close(); 
  Serial.println("\nFile datalog6.txt written - FINISHED!\n");  
}
void loop() {}

The second sketch reads the data we have saved in the datalog6.txt file. It splits each line/record into the 3 strings and then converts one to an Integer and the another to Floating Point. Just to prove that they are now stored as numbers it multiplies them together and displays the result.

// Read the data back from a log file: 'datalog6.txt'
// Tony Goodhew 21 Sept 2020
// SD reader on TFT shield
// Tutorial45.com

#include <SPI.h>
#include <SD.h>

const int chipSelect = 10;

void setup() {
  // Open serial communications and wait for port to open:
  Serial.begin(9600);
  while (!Serial) {
    ; // wait for serial port to connect. Needed for native USB port only
  }
  Serial.print("Initializing SD card...");

  // see if the card is present and can be initialized:
  if (!SD.begin(chipSelect)) {
    Serial.println("Card failed, or not present");
    // don't do anything more:
    while (1);
  }
  Serial.println("card initialized.");

  // Open the file
  File dataFile = SD.open("datalog6.txt");
  Serial.println("Reading datalog6.txt");
  String j = ""; // Holds a line from the data file (3 fields = 1 record)
  
  if (dataFile) {
    while (dataFile.available()) {        // Not reached the End Of File     
      j = dataFile.readStringUntil('\n'); // Get single line from file
      Serial.println("\n"+j);
      int comma1 = j.indexOf(','); 
      int comma2 = j.indexOf(',', comma1 + 1); 
      Serial.println("Commas: " + String(comma1) + " "+ String(comma2));
      // Separate back into 3 strings at the commas
      String ii = j.substring(0,comma1);              // integer
      String sname = j.substring(comma1 +1, comma2);  // string
      String ff = j.substring(comma2 +1);             // float
      // Print out the strings
      Serial.println(ii);
      Serial.println(sname);
      Serial.println(ff);
      int iOut = ii.toInt(); // Convert back to integer
      float fOut = ff.toFloat();  // Convert back to Floating Point
      float res = iOut * fOut;    // Calculation with both numbers
      Serial.println(sname +": " + String(res)+"\n");  // Output the result
    }
    dataFile.close();
  }
  // if the file isn't open, print up an error message
  else {
    Serial.println("error opening datalog6.txt");
  }
}
void loop() {}

Using the Touch Layer

This is the part that often causes the most trouble with many owners giving up at this point. It may be because there are several different configurations of the pins used to connect to the touch layers of the screen on the many varied breakout boards and shields using this display. In this case four of the pins are used, at different times, to control both the graphics or the touch elements of the screen.

How does a touch screen sense position?

This is a resistive touch screen, rather than a capacitive one. Above the graphics, layers are two transparent resistive layers held apart by tiny dimples. One is connected at the top and bottom and the other at the sides. A potential difference is applied across them and when the stylus or a finger presses on the screen an electrical connection is made between the resistive layers.

The Analog pins are used to measure the voltages at that point on the two resistive layers, one at a time, in the same manner as we read the voltage from the wiper of a potentiometer – a potential divider. Using these values, it is possible to calculate, quite accurately, the coordinates of the point on the screen where the pressure has been applied. Calibration is often needed to improve accuracy. Adafruit suggests reading the resistance across the X plate (XP = D8 and XM = A2). On my board, I got 341 Ohms. Use this value as SENSITIVITY.

MINPRESSURE && p.z < MAXPRESSURE) { /* // Debugging Serial.print("X = "); Serial.print(p.x); Serial.print("\tY = "); Serial.print(p.y); Serial.print("\tPressure = "); Serial.println(p.z); */ // Scale Touch values to fit TFT screen // Adjust final number to get drawn dot under the stylus point (fudge factors!) p.x = map(p.x, TS_MINX, TS_MAXX, tft.width(), 0) -10; p.y = map(p.y, TS_MINY, TS_MAXY, tft.height(), 0)-14; /* // Debugging Serial.print("("); Serial.print(p.x); Serial.print(", "); Serial.print(p.y); Serial.println(")"); */ if (p.y < 40){ // In the palette area? if (p.x <30){ // Black to clear drawing area tft.fillRect(0, 40, 240,299, BLACK);} else{ // Change colour cc = c[p.x / 30]; } } else{ tft.fillCircle(p.x, p.y, 2, cc); // Draw dot at stylus point } } }" style="color:#adbac7;display:none" aria-label="Copy" class="code-block-pro-copy-button">

// Simple Drawing Script for AZ-Delivery TFT Touch 240x320 Shield
// Tony Goodhew 30 Sept 2020
// Modified from Adafruit examples for a similar shield
// Tutorial45.com
// Adafruit GFX Libraries
#include <Adafruit_GFX.h>
#include <Adafruit_TFTLCD.h>
#include <TouchScreen.h>

#define LCD_CS A3     // Chip Select goes to Analog 3
#define LCD_CD A2     // Command/Data goes to Analog 2
#define LCD_WR A1     // LCD Write goes to Analog 1
#define LCD_RD A0     // LCD Read goes to Analog 0
#define LCD_RESET A4  // Can alternately just connect to Arduino's reset pin

// 16-bit colour values:
#define BLACK 0x0000
#define BLUE 0x001F
#define RED 0xF800
#define GREEN 0x07E0
#define CYAN 0x07FF
#define MAGENTA 0xF81F
#define YELLOW 0xFFE0
#define WHITE 0xFFFF
unsigned int c[] = {BLACK,RED,GREEN,BLUE,CYAN,MAGENTA,YELLOW,WHITE};
int cc = c[1];

// Create the TFT (Graphics) object - named pins
Adafruit_TFTLCD tft(LCD_CS, LCD_CD, LCD_WR, LCD_RD, LCD_RESET);

// Set up the touch screen element of the TFT screen
#define YP A3  // must be an analog pin, use "An" notation!
#define XM A2  // must be an analog pin, use "An" notation!
#define YM 9   // can be a digital pin
#define XP 8   // can be a digital pin
#define SENSITIVITY 341                   // Was 300 = Resistance A2 to D8                                                                         
#define MINPRESSURE 10
#define MAXPRESSURE 1000
#define TS_MINX  150
#define TS_MINY  120
#define TS_MAXX  920
#define TS_MAXY  940
#define MINPRESSURE 10
#define MAXPRESSURE 1000
// Create Touch Screen object
TouchScreen ts = TouchScreen(XP, YP, XM, YM, SENSITIVITY);

void palette(){       // Create colour 'buttons' at top of screen
   int w = 30;
   int h = 40;
   tft.fillRect(0, 0, w, h, BLACK);
   tft.fillRect(w, 0, w, h, RED);
   tft.fillRect(w*2, 0, w, h, GREEN);
   tft.fillRect(w*3, 0, w, h, BLUE);
   tft.fillRect(w*4, 0, w, h, CYAN);
   tft.fillRect(w*5, 0, w, h, MAGENTA);
   tft.fillRect(w*6, 0, w, h, YELLOW);
   tft.fillRect(w*7, 0, w, h, WHITE); 
}
//---------SETUP--------------------
void setup() {
  Serial.begin(9600);
  tft.reset();
  tft.begin(0x9341);  // SDFP5408
  tft.fillRect(0,0, 240,320, BLACK);  // Drawing area
  palette();  // Drawing colour buttons
}
//---------Main Loop------------
void loop(){
  TSPoint p = ts.getPoint(); // Read the Touch Screen
  // Shared pins - fix direction
  pinMode(XM, OUTPUT);
  pinMode(YP, OUTPUT);

  // Check for pressure on screen
  if (p.z > MINPRESSURE && p.z < MAXPRESSURE) {
/*  // Debugging     
    Serial.print("X = "); Serial.print(p.x);
    Serial.print("\tY = "); Serial.print(p.y);
    Serial.print("\tPressure = "); Serial.println(p.z);
*/      
    // Scale Touch values to fit TFT screen 
    // Adjust final number to get drawn dot under the stylus point (fudge factors!)
    p.x = map(p.x, TS_MINX, TS_MAXX, tft.width(), 0) -10;
    p.y = map(p.y, TS_MINY, TS_MAXY, tft.height(), 0)-14; 
    
/*  // Debugging   
    Serial.print("("); Serial.print(p.x);
    Serial.print(", "); Serial.print(p.y);
    Serial.println(")");
*/    
    if (p.y < 40){                              // In the palette area?
      if (p.x <30){                             // Black to clear drawing area
        tft.fillRect(0, 40, 240,299, BLACK);}
      else{                                     // Change colour
        cc = c[p.x / 30];
      }
    }
    else{
      tft.fillCircle(p.x, p.y, 2, cc);         // Draw dot at stylus point
    }
  }
}

Try running the sketch to draw on the screen. The BLACK palette ‘button’ clears the screen and the others change the ‘ink’ colour. If the dot drawn is not directly under the stylus you can adjust the ‘fudge factors’ in the scaling section.

16-bit Colour Mixing Project

As a final example here is a sketch which shows off the Touch screen with buttons, bar graphs and colours. The buttons allow the user to adjust the RGB mix to display all the possible colours available. If you find one you particularly like it displays the hex value of the 16-bit colour.

Gently pressing on the buttons at the bottom with the stylus changes the RGB values within their allowed ranges. The bars move to show the fraction of maximum possible for each of the red, green and blue values.

3){bc = BLUE;} tft.fillRect(5 + i *(w+10), y, w, h, bc); } tft.setTextColor(WHITE); tft.setTextSize(3); for (int i=0; i<6; i = i + 2){ tft.setCursor(12 + i *(w+10), y +4); tft.println("+");} for (int i=1; i<6; i = i + 2){ tft.setCursor(12 + i *(w+10), y +4); tft.println("-");} } void show(){ // Display values and bar graphs unsigned int n = red * 2048 + green * 32 + blue; tft.fillRect(0, 0, 240, 60, n); tft.drawFastVLine(19, 95, 90, 0x7BEF); // Graph axis tft.drawFastVLine(18, 95, 90, 0x7BEF); tft.setTextSize(3); tft.setTextColor(WHITE); if (n > 0xF2BF){tft.setTextColor(BLACK);} // Black on bright colours tft.setCursor(85,20); tft.println(n,HEX); tft.fillRect(0, 230, 240, 46, BLACK); String rS = String(red); if (red < 10){rS = " " + rS;} // Left alignment tft.setTextColor(WHITE); tft.setCursor(25,230); tft.println(rS); String gS = String(green); if (green < 10){gS = " " + gS;} tft.setCursor(105,230); tft.println(gS); String bS = String(blue); if (blue < 10){bS = " " + bS;} tft.setCursor(186,230); tft.println(bS); tft.setTextSize(2); int rp = red * 100 / 31; int gp = green * 100 / 63; int bp = blue * 100 / 31; String rz = String(rp) + "%"; String gz = String(gp) + "%"; String bz = String(bp) + "%"; if (rp < 100){rz = " " + rz;} if (rp < 10){rz = " " + rz;} tft.setCursor(13,260); tft.println(rz); if (gp < 100){gz = " " + gz;} if (gp < 10){gz = " " + gz;} tft.setCursor(92,260); tft.println(gz); if (bp < 100){bz = " " + bz;} if (bp < 10){bz = " " + bz;} tft.setCursor(174,260); tft.println(bz); if (old_r != red){ // red value changed? graph(20,100,rp,RED); // Update graph old_r = red; } if (old_g != green){ // green value changed? graph(20,130,gp,GREEN); old_g = green; } if(old_b != blue){ // blue value change graph(20,160,bp,BLUE); old_b = blue; } } //---------SETUP------------------ void setup() { Serial.begin(9600); tft.reset(); tft.begin(0x9341); // SDFP5408 tft.fillRect(0,0, 240,320, BLACK); // Drawing area palette(); // Drawing buttons show(); // Display the inital values } //---------Main Loop------------ void loop(){ TSPoint p = ts.getPoint(); // Read the Touch Screen // Shared pins - fix direction pinMode(XM, OUTPUT); pinMode(YP, OUTPUT); // Check for pressure on screen if (p.z > MINPRESSURE && p.z < MAXPRESSURE) { // Scale Touch values to fit TFT screen // Adjust final values to improve accuracy p.x = map(p.x, TS_MINX, TS_MAXX, tft.width(), 0) -10; p.y = map(p.y, TS_MINY, TS_MAXY, tft.height(), 0)-14; if ((p.y >= 300) & (p.y <= 330)){ // In the button area? if ((p.x >= left[0]) & (p.x <= right[0])){ // Process buttons red = red +1; // as necessary if (red > 31){red = 31;} } else if ((p.x >= left[1]) & (p.x <= right[1])){ red = red -1; if (red < 0){red = 0;} } else if ((p.x >= left[2]) & (p.x <= right[2])){ green = green + 1; if (green > 63){green = 63;} } else if ((p.x >= left[3]) & (p.x <= right[3])){ green = green -1; if (green < 0){green = 0;} } else if ((p.x >= left[4]) & (p.x <= right[4])){ blue = blue + 1; if (blue > 31){blue = 31;} } else if ((p.x >= left[5]) & (p.x <= right[5])){ blue = blue - 1; if (blue < 0){blue = 0;} } } // Update Display show(); } }" style="color:#adbac7;display:none" aria-label="Copy" class="code-block-pro-copy-button">

// Project Sketch for AZ-Delivery TFT Touch 240x320 Shield
// Tony Goodhew 2 October 2020
// Tutorial45.com
// Adafruit GFX Libraries
#include <Adafruit_GFX.h>
#include <Adafruit_TFTLCD.h>
#include <TouchScreen.h>

#define LCD_CS A3     // Chip Select goes to Analog 3
#define LCD_CD A2     // Command/Data goes to Analog 2
#define LCD_WR A1     // LCD Write goes to Analog 1
#define LCD_RD A0     // LCD Read goes to Analog 0
#define LCD_RESET A4  // Can alternately just connect to Arduino's reset pin

// 16-bit colour values:
#define BLACK 0x0000
#define BLUE 0x001F
#define RED 0xF800
#define GREEN 0x07E0
#define WHITE 0xFFFF

// Create the TFT (Graphics) object - named pins
Adafruit_TFTLCD tft(LCD_CS, LCD_CD, LCD_WR, LCD_RD, LCD_RESET);

// Set up the touch screen element of the TFT screen
#define YP A3  // must be an analog pin, use "An" notation!
#define XM A2  // must be an analog pin, use "An" notation!
#define YM 9   // can be a digital pin
#define XP 8   // can be a digital pin
#define SENSITIVITY 341                   // Was 300 = Resistance A2 to D8                                                                         
#define MINPRESSURE 10
#define MAXPRESSURE 1000
#define TS_MINX  150
#define TS_MINY  120
#define TS_MAXX  920
#define TS_MAXY  940
#define MINPRESSURE 10
#define MAXPRESSURE 1000
// Create Touch Screen object
TouchScreen ts = TouchScreen(XP, YP, XM, YM, SENSITIVITY);

int left[] ={5,45,85,125,165,205};    // left edge of buttons
int right[]={35,75,115,155,195,235};  // right edge of buttons
int red = 15;  // Colours set at mid-points
int green = 31;
int blue = 15;
int old_r = 0;
int old_g = 0;
int old_b = 0;

void graph(int xx, int yy, int p, unsigned int col){
  // Draw a bar graph
  tft.fillRect(xx, yy, 200, 20, BLACK);  // Overwrite to background colour
  tft.fillRect(xx, yy, p * 2, 20, col);  // New bar graph
}
  
void palette(){
  // Create 'buttons' near bottom of screen
  int w = 30;
  int h = 30;
  int y = 280;
  for (int i=0; i<6;i++){
    unsigned int bc = GREEN;
    if (i < 2){bc = RED;}
    if (i > 3){bc = BLUE;}
    tft.fillRect(5 + i *(w+10), y, w, h, bc);
  }
  tft.setTextColor(WHITE);
  tft.setTextSize(3);
  for (int i=0; i<6; i = i + 2){
    tft.setCursor(12 + i *(w+10), y +4);
    tft.println("+");}
  for (int i=1; i<6; i = i + 2){
      tft.setCursor(12 + i *(w+10), y +4);
      tft.println("-");}
}
void show(){
  // Display values and bar graphs
  unsigned int n = red * 2048 + green * 32 + blue;
  tft.fillRect(0, 0, 240, 60, n);
  tft.drawFastVLine(19, 95, 90, 0x7BEF); // Graph axis  
  tft.drawFastVLine(18, 95, 90, 0x7BEF);
  tft.setTextSize(3);
  tft.setTextColor(WHITE);
  if (n > 0xF2BF){tft.setTextColor(BLACK);}  // Black on bright colours
  tft.setCursor(85,20);
  tft.println(n,HEX);
  tft.fillRect(0, 230, 240, 46, BLACK);
  String rS = String(red);
  if (red < 10){rS = " " + rS;}  // Left alignment
  tft.setTextColor(WHITE);
  tft.setCursor(25,230);
  tft.println(rS);
  String gS = String(green);
  if (green < 10){gS = " " + gS;}
  tft.setCursor(105,230);
  tft.println(gS);
  String bS = String(blue);
  if (blue < 10){bS = " " + bS;}
  tft.setCursor(186,230);
  tft.println(bS);
  tft.setTextSize(2);
  int rp = red * 100 / 31;
  int gp = green * 100 / 63;
  int bp = blue * 100 / 31;
  String rz = String(rp) + "%";
  String gz = String(gp) + "%";
  String bz = String(bp) + "%";
  if (rp < 100){rz = " " + rz;}
  if (rp < 10){rz = " " + rz;}
  tft.setCursor(13,260);
  tft.println(rz);
  if (gp < 100){gz = " " + gz;}
  if (gp < 10){gz = " " + gz;}
  tft.setCursor(92,260);
  tft.println(gz);
  if (bp < 100){bz = " " + bz;}
  if (bp < 10){bz = " " + bz;}
  tft.setCursor(174,260);
  tft.println(bz);
  if (old_r != red){                // red value changed?
    graph(20,100,rp,RED);           // Update graph
    old_r = red;
    }
  if (old_g != green){              // green value changed? 
    graph(20,130,gp,GREEN);
    old_g = green;   
  }
  if(old_b != blue){               // blue value change  
    graph(20,160,bp,BLUE);
    old_b = blue;
  }   
}
//---------SETUP------------------
void setup() {
  Serial.begin(9600);
  tft.reset();
  tft.begin(0x9341);  // SDFP5408
  tft.fillRect(0,0, 240,320, BLACK);    // Drawing area
  palette();  // Drawing buttons
  show();  // Display the inital values  
}
//---------Main Loop------------
void loop(){
  TSPoint p = ts.getPoint(); // Read the Touch Screen
  // Shared pins - fix direction
  pinMode(XM, OUTPUT);
  pinMode(YP, OUTPUT);

  // Check for pressure on screen
  if (p.z > MINPRESSURE && p.z < MAXPRESSURE) {
      
    // Scale Touch values to fit TFT screen 
    // Adjust final values to improve accuracy
    p.x = map(p.x, TS_MINX, TS_MAXX, tft.width(), 0) -10;
    p.y = map(p.y, TS_MINY, TS_MAXY, tft.height(), 0)-14; 
    
    if ((p.y >= 300) & (p.y <= 330)){               // In the button area?
      if ((p.x >= left[0]) & (p.x <= right[0])){    // Process buttons
        red = red +1;                               //   as necessary
        if (red > 31){red = 31;}
      }
      else if ((p.x >= left[1]) & (p.x <= right[1])){ 
        red = red -1;
        if (red < 0){red = 0;}
      }
      else if ((p.x >= left[2]) & (p.x <= right[2])){ 
        green = green + 1;
        if (green > 63){green = 63;} 
      }
      else if ((p.x >= left[3]) & (p.x <= right[3])){ 
        green = green -1;
        if (green < 0){green = 0;}
      }
      else if ((p.x >= left[4]) & (p.x <= right[4])){ 
        blue = blue + 1;
        if (blue > 31){blue = 31;}
      }
      else if ((p.x >= left[5]) & (p.x <= right[5])){ 
        blue = blue - 1;
        if (blue < 0){blue = 0;}
      }
    }
    // Update Display
    show();
  }
}

Conclusion

There is a small amount of jitter as the bar graph re-draws, but overall, the shield works quickly and well. After the screen has updated and is waiting for a touch, the image is steady, sharp, and bright. Once you have calibrated the touch device, it is very accurate, as demonstrated by the small (30×30 pixel buttons), and provides excellent, colorful graphics on a usefully large display.

The SD card reader is a bonus and could always be used via jump wires to record values from sensors on the other pins. These values could then be displayed graphically with a different sketch.

I was very pleased with the display’s quality and the Touch device’s accuracy. It sits neatly and securely on a UNO or a MEGA 2560. With an SD card reader included, it was excellent value, and I will make good use of it in the future.

Alegoo Super Starter Kit and UNO R3 Project Reviews – Gift Guide

Andreea — Tue, 27 Feb 2024 07:41:59 +0000

Alegoo Super Starter Kit and UNO R3 Project Reviews – Gift Guide

Acquiring a solid foundation in electronics and programming starts with understanding the basics, tinkering, and expanding one’s knowledge base through practical experiences. The Elegoo UNO Project Super Starter Kit with UNO R3 allows every budding electronics and programming enthusiast to explore the world of electronics.

To ease the learning and teaching process for students and educators, the Elegoo UNO Project Super Starter Kit provides the tools and tutorials required to build with the kit. To understand the excellent resources it brings, a detailed review of the kit’s features and projects will be provided to help you decide on purchasing one.

Components in the Elegoo UNO Project Super Starter Kit

Starting with the electronics components in the kit, it is easy to note that it comes with various components that can be leveraged to accomplish diverse projects. The kit contains:

A UNO R3 Controller Board
An LCD 1602 Module (with pin header)
Breadboard Expansion Board
Power Supply Module
Joystick Module
IR Receiver
Servo Motor
Stepper Motor
ULN2003 Stepper Motor Driver Board
Ultrasonic Sensor
DHT11 Temperature and Humidity Module
A 9Volts Battery
65 Jumper Wire
USB Cable 1pcs
Active Buzzer 1pcs
Passive Buzzer 1pcs
Potentiometer 1pcs
5V Relay 1pcs
Breadboard 1pcs
Remote 1pcs
Tilt Switch 5pcs
Button (small) 1pcs
1 digit 7-segment Display 1pcs
4 digit 7-segment Display 5pcs
Yellow LED 5pcs
Blue LED 5pcs
Green LED 5pcs
Red LED 1pcs
RGB LED 2pcs
Photo resistor 1pcs
Thermistor 2pcs
Diode Rectifier (1N4007) 2pcs
NPN Transistor (PN2222) 1pcs
IC 74HC595 120pcs
Resistor 10pcs
Female-to-male DuPont Wire.
Instruction Manual

Getting Started with the Elegoo UNO Project Super Starter Kit

Experienced electronics and programming enthusiasts will immediately understand the possibilities attached to this kit and every component in it…but it is a starter kit. This means it is geared towards first-time users than experts; thus, a brief explanation of the most important components in the kit is required.

Check Current Price

Thankfully, the super starter kit comes with an instructional manual or guide in the form of a CD. The guide includes sample codes for specific projects attached to a specific component, an extensive library, and details about each component you will work with. Thus, you are expected to rely heavily on the instructions in your starter pack CD to understand better what the kit is capable of and the very important role of the Arduino Integrated Development Environment (IDE) in executing projects.

Now, no Arduino project can be started without an IDE. The integrated development environment is the platform for writing your codes, which directs the Arduino board and the breadboard expansion on what action to take. The IDE is installed on a computer and provides you with the interface and tools for coding. You can download the Arduino IDE for this kit from the Elegoo website here.

Once downloaded, you’re finally ready to immerse yourself into the DIY electronics world the starter kit provides. Lastly, plug the Arduino board to your computer so it can begin receiving instructions. Plugging the Arduino board to your computers is as easy as simply connecting the accompanying USB board to both the Arduino board and your computer.

Lessons You Should Take Advantage of with the Super Starter Kit

The good people at Elegoo provide every user with 24 lessons from the kit. These lessons can be found in the instructions CD highlighted above and it is the best way to get familiar with using an Arduino board and provisioning electronics components.

Check Current Price

And what do the lessons cover?

The 24 lessons you get in the tutorial focus on the basics, such as loading specific programs or code libraries and assigning them to folders for specific components and use cases, and how to attach external electronic components such as LED lights and LCD screen to the Arduino board. The basics then lead to some practical lessons, such as programming a timer or clock onto the LCD module and setting up the temperature and humidity module to read the temperature of your environment.

The lessons in the tutorials Elegoo provides right out of the kit prepare you for undertaking more complex projects, which the components in the kit support. The fourth lesson is where the action starts, and you’ll be introduced to the RGB LED project, which involves getting the multicolored LED lights in the kit to form a strip with the lights coming on in specified sequences. As expected, the codes and instructions for executing the RGB LED project have been provided in the official Elegoo tutorials.

The next projects include programming the digital buzzer, active buzzer, tilt ball switch, Ultrasonic sensor module, temperature, and the other components in the box. Like each lesson in the tutorial, the codes and instructions needed to set up each of these projects have been provided by Elegoo. Once you have completed the 24 lessons Elegoo provides you would gain insight into what can be accomplished with an Arduino board and the right components.

Sample Tasks to Consider Doing with the Elegoo UNO Project Super Starter Kit

Learning Elegoo’s lessons is simply the beginning of the journey to becoming proficient in electronics DIY tasks. The Elegoo UNO super starter kit is a powerful tool that allows you to explore further than the lessons in the official tutorial. Here, 2 sample projects or tasks will be included, which you can explore.

The Ultrasonic Distance Measurement Project

The basics of this project involve using an ultrasonic sensor to measure distances. The most important components this project requires are the Ultrasonic sensor, the UNO R3, the expansion board, and the LCD, which displays the distance measured and can be found in the kit.

The project involves connecting the expansion board to the UNO using wires and wiring the Ultrasonic sensor and the LCD display to the breadboard. To get the Ultrasonic distance measurement project working, you will also need to input the required code into the Arduino IDE. You can find the details for wiring and the code for this project here.

Joystick Control of a DC Motor

This project takes things up a notch by attempting to control the direction and speed at which a DC motor rotates using a joystick. Note that the Elegoo Super Starter Kit provides its most important components, including the joystick, the DC motor, and an Arduino UNO R3.

The project involves wiring the UNO R3 with the breadboard to extend its functionalities and installing the DC motor and joystick to the breadboard. If successfully done, the DC motor’s speed and direction can be manipulated using a joystick. You can find the details and code for this project here.

Conclusion

The Elegoo UNO Project Super Starter Kit, including a tutorial and UNO R3, is highly regarded as an excellent kit for understanding the electronics basics with Arduino.

It is top-rated by DIY lovers and professionals featured on YouTube who affirm its effectiveness in introducing Arduino basics at a reasonable price. Its variety of project options and the chance to experiment individually also enhance its attractiveness.

Mcp2515 Arduino Project: Using a Controller Area Network (CAN) with Arduino

Andreea — Mon, 26 Feb 2024 22:45:05 +0000

Mcp2515 Arduino Project: Using a Controller Area Network (CAN) with Arduino

This guide presumes that the user is adept in integrating LEDs, potentiometers, and sensors into the Arduino platform, has worked with SPI and I2C devices, and is prepared to level up and initiate data exchange between Arduinos. Employing this network is more straightforward and more comprehensible than radio communication; however, it necessitates wiring between the Arduinos.

CAN, a robust vehicle data bus standard, facilitates communication and data sharing among microcontrollers without needing a host computer. This message-based protocol was initially created to conserve copper in automotive wiring systems.

Bosch, the German company, came up with CAN in 1983, which was first applied in the Mercedes-Benz W140 in 1991. Modern vehicles may incorporate approximately seventy electronic devices such as sensors, actuators, a unit for managing the engine, and an automatic engine start/stop system.

These rely on getting readings from accelerometers, thermometers, and gas sensors and sending commands to actuators. Great accuracy is required, and the CAN bus has a great deal of cyclic redundancy checking (CRC) built in to ensure safety.

Small data frames are used with a maximum of 8 data bytes in each packet. Each node has an ID number, and transmission clashes on the network are dealt with by the lower-priority frame backing off. Priority depends on the allocated ID given to the device. Lower ID numbers have higher priority.

All devices, including the transmitting device, receive data packets sent on the network. The system allows one device to request data from another via a Remote Transmission Request (RTR) frame, but some authorities recommend not using this facility.

Although initially designed for automotive situations, this bus offers a simple and inexpensive system for hobby electronics projects. The node modules are available from a wide range of sources. Many use an MCP2515 CAN Bus controller with an SPI interface and an MCP2551 CAN transceiver.

The fields of a standard CAN frame

Field	Bits
Start of Frame SOF	1
Standard Identifier ID	11
Control	6
Data	64 – 8 bytes
Cyclic Redundancy Check – CRC	16
Acknowledgement – ACK	2
End of Frame – EOF	7

A minimum of two nodes is connected with a twisted pair of wires with a nominal impedance of 120 Ohms. The CAN high (CANH) and CAN low (CANL) pins are provided on the modules. CANH is connected, and CANL is connected with 120 Ohm resistors included at the end nodes of the bus.

Breakout board node modules are readily available, and I used some supplied by AZ-Delivery. (A 3-pack costs less than two singles!) SPI signals drive the modules and are very easy to connect to Arduino boards. I used a Nano at one end and a UNO at the other end of the network. Jumpers were used to short the J1 pins to include the built-in 120 Ohm termination resistors.

The pins on J4 were connected to the Arduinos using pins 10 to 13. The large blue screw terminals labeled H and L were used to link the modules together with the network-twisted pair of wires. I added an LED with a protective current limiting resistor to pin D5 on the Nano.

System Test

We will need:

2 CAN modules
Arduino UNO
Arduino Nano – They need different COM values
Suitable USB cables
Connection wire
LED
560 Ohm resistor

Connections

CAN Module	Arduino UNO and Nano
INT	D6 (Not needed for these examples)
SCK	D13
SI	D11
SO	D12
CS	D10
GND	GND
VCC	5 volts

H	H on the other module
L	L on the other module
J1 pins shorted together (to provide 120 Ohm network termination.)

Library

You need an Arduino library to drive these boards. There are several to choose from, but I picked mcp_can, which can be found here: https://github.com/Seeed-Studio/CAN_BUS_Shield

because it had several example sketches. This is supplied as a .zip file and is easy to install.

At this point, you need a bit of care and organization. If using Windows, you will need two separate instances of the Arduino IDE running on your computer with different ports / COM numbers. You need to start each of them from the Start button. (Do not try to get the second one by clicking NEW on the first IDE window.)

Keep the sending setup on the right. (UNO right side of the bench, USB cable in the right USB socket, IDE and Serial Monitor windows on the right side of the screen – COM27.)

Keep the receiving setup on the left. (Nano, with optional LED on pin D5, USB socket, IDE, and Serial Monitor on the left – COM11.)

Check the port numbers at the bottom right corner of each IDE window. They must be different.

Copy the SEND sketch into the right IDE and compile/load it. Then copy the RECEIVE sketch into the left IDE and compile/load it.

Turn on the Serial monitors (115200 baud) and press the reset button on the right, sending Arduino UNO to start sending data again.

Both monitor windows should fill up so that you can see data flowing via the network from one to the other.

Basic SEND sketch

// Demonstration SEND with CAN-BUS Module - UNO
// Tony Goodhew 18th Nov 2020
// Tutorial45.com
#include <mcp_can.h>
#include <SPI.h>

const int SPI_CS_PIN = 10;

MCP_CAN CAN(SPI_CS_PIN); // Chip select

void setup() {
    Serial.begin(115200);

    while (CAN_OK != CAN.begin(CAN_500KBPS)) {
        Serial.println("CAN BUS Module failed to start");
        Serial.println(" Try again");
        delay(100);
    }
    Serial.println("CAN BUS Module started.");

    for (int i=0; i <256; i++){
      Serial.println("-----------------------------");
      int q = random(0,100);
      int ledState = 1;
      if (q < 40){ledState = 0;}
      // Place data to be sent in output buffer
      byte bufout[8] = {ledState, i, i+1, 255, 100, 200, random(0,255), 255-i};
  
      // Sending:  ID = 0x05, standard frame, data len = 8, data in bufout
      CAN.sendMsgBuf(0x05, 0, 8, bufout);
      Serial.print("Packet sequence # ");
      Serial.println(i);
      for(int i = 0; i<8; i++){
          Serial.print(bufout[i]);
          Serial.print("\t"); 
      }
      Serial.println();
      delay(100);       // slow things down
    }
}
void loop(){}

This sketch sends 256 packets of data across the network. Each packet is made up from the ID of the sending node, “05” hex, and 8 bytes:

randomly generated 0 or 1, to turn the LED ON/OFF,
sequence value 0 to 255
sequence value + 1 – note it overflows on last frame (“0” not “256”)
constant 255
constant 100
constant 200
random numbers 0 to 255
sequence counting down from 255 to 0

Basic RECEIVE sketch

// Demonstration RECEIVE with CAN-BUS Module - Nano
// LED on pin 5
// Tony Goodhew 18th Nov 2020
// Tutorial45.com
#include <SPI.h>
#include <mcp_can.h>

const int spiCSPin = 10;
const int ledPin = 5; // With protection resistor

MCP_CAN CAN(spiCSPin);

void setup(){
    Serial.begin(115200);
    pinMode(ledPin,OUTPUT);

    while (CAN_OK != CAN.begin(CAN_500KBPS)) { 
        Serial.println("CAN BUS Module failed to start");
        Serial.println(" Try again");
        delay(100);
    }
    Serial.println("CAN BUS Module started.");
}

void loop(){
    byte len = 0;
    byte bufin[8];

    if(CAN_MSGAVAIL == CAN.checkReceive()){
        CAN.readMsgBuf(&len, bufin);
        unsigned long canId = CAN.getCanId();
        Serial.println("-----------------------------");
        Serial.print("Data from ID: 0x");
        Serial.println(canId, HEX);

        for(int i = 0; i<len; i++){
            Serial.print(bufin[i]);
            Serial.print("\t");
            // Update LED state from 1st data item 
            if(i==0)
              {digitalWrite(ledPin, bufin[0]);} 
        }
        Serial.println();
    }
}

All data arrived safely with the LED flashing as required.

Project: Sending data both ways

The project reuses the circuit from the prior example to exhibit bi-directional data transmission. In this case, the Nano transmits readings of temperature and humidity collected from a simulated sensor to the UNO. Simultaneously, the UNO forwards a sequence number and multiple pre-recorded brightness values to the Nano. This data prompts the Nano to adjust the luminosity of the D5-pin LED. The activity is recorded at both ends to observe the ongoing operation.

I have simulated the sensor to have a temperature range from -40 to 100 and use brightness values between 0 and 119. Simulation allows us to concentrate on the CAN bus rather than the sensors, which you may not have handy.

The CAN bus has built-in collision avoidance arbitration. If two nodes try to send data packets simultaneously, the one with the higher priority gets precedence, and the lower priority node tries again after a short delay when the bus is clear.

We can use delay(XX); on the Arduino end because it sends more data and only processes received data every 0.5 seconds. The Nano needs non-blocking timing because it needs to keep processing incoming data while occasionally sending out data.

Sometimes, we need to ‘code’ a data item so that it can be transmitted with bite-sized pieces. A byte can contain values from zero to 255. If we need to send integer temperatures ranging from -40 to 100 a simple trick is to add 40 before you send it, and take 40 off again once it has arrived.

If you want to send floating point temperatures, you could split the temperature into whole numbers and fractional parts. Send the whole number part in the same manner in one byte and the decimal part multiplied by 100 in a second byte. At the receiving end, divide the ‘decimal byte’ by 100 and recombine by addition to get the original temperature.

Nano Code

nextTime){ // Has 0.5 seconds passed since last send? nextTime = nextTime + 500; // Update next time to send // Simulate sensors int temperature = temps[tp]; // Fetch simulated temperature tp = tp + 1; if (tp > 11){tp = 0;} int humidity = hums[hp]; // Fetch simulated humidity hp = hp + 1; if (hp > 12){hp = 0;} byte temp = byte(temperature + 40); // code so never negative byte hum = byte(humidity); byte bufout[] = {temp, hum}; // Put send data into buffer CAN.sendMsgBuf(0x20, 0, 2, bufout); // Id = 0x20 // Send the packet Serial.println("-----------------------------"); // Log packet sent to Serial Monitor Serial.print("Sent Sensor Packet "); for(int i = 0; i<2; i++){ Serial.print(bufout[i]); Serial.print("\t"); } Serial.println(); } }" style="color:#adbac7;display:none" aria-label="Copy" class="code-block-pro-copy-button">

// Demonstration RECEIVE and SEND with CAN-BUS Module - NANO
// LED on pin 5 with 560 Ohm  - PWM available
// Tony Goodhew 24th Nov 2020
// Tutorial45.com
#include <SPI.h>
#include <mcp_can.h>

const int spiCSPin = 10;
const int ledPin = 5; // With protection resistor- PWM pin
// Simulated temperature and humidity values
const int temps[] ={-40,-34,-27,-15,0,5,11,15,17,24,34}; // 11 items
const int hums[] = {20,30,40,50,60,75,80,95,72,56,48,35}; // 12 items
int tp = 0; // temperature data pointer
int hp = 0; // humidity data pointer
unsigned long nextTime; // For non-blocking delays
MCP_CAN CAN(spiCSPin);

void setup(){
    Serial.begin(115200);
    pinMode(ledPin,OUTPUT);
    nextTime = 500 + millis(); // 0.5 seconds in the future

    while (CAN_OK != CAN.begin(CAN_500KBPS)) { 
        Serial.println("CAN BUS Module failed to start");
        Serial.println(" Try again");
        delay(100);
    }
    Serial.println("CAN BUS Module started.");
}
void loop(){
  byte len = 0;
  byte bufin[8];
  if(CAN_MSGAVAIL == CAN.checkReceive()){ // Data packet available?
    CAN.readMsgBuf(&len, bufin);          // Read data packet
    unsigned long canId = CAN.getCanId(); // Get the ID of sender  
    Serial.print("Data from ID: 0x");
    Serial.print(canId, HEX);
    Serial.print("\t");
    if (canId == 0x05){                   // Is it from UNO?
      for(int i = 0; i<len; i++){         // Print the contents of packet received
        Serial.print(bufin[i]);
        Serial.print("\t");  
      }
    Serial.println();
    // Update LED brightness from second data item 
    analogWrite(ledPin, bufin[1]);
    }
  }
  // Every 0.5 seconds
  if (millis() > nextTime){ // Has 0.5 seconds passed since last send?
    nextTime = nextTime + 500; // Update next time to send
    // Simulate sensors
    int temperature = temps[tp]; // Fetch simulated temperature
    tp = tp + 1;
    if (tp > 11){tp = 0;}    
    int humidity = hums[hp];     // Fetch simulated humidity
    hp = hp + 1;
    if (hp > 12){hp = 0;}
    byte temp = byte(temperature + 40); // code so never negative
    byte hum = byte(humidity);
    byte bufout[] = {temp, hum}; // Put send data into buffer
    CAN.sendMsgBuf(0x20, 0, 2, bufout); // Id = 0x20 // Send the packet
    Serial.println("-----------------------------"); // Log packet sent to Serial Monitor
    Serial.print("Sent Sensor Packet ");
    for(int i = 0; i<2; i++){
      Serial.print(bufout[i]);
      Serial.print("\t"); 
    }
    Serial.println();
  }
}

Uno Code

120) {brightness = 0;} sequence = sequence + 1; // Increment sequence counter if (sequence > 255) {sequence = 0;} byte bufout[] = {sequence, brightness}; // Put values in output buffer CAN.sendMsgBuf(0x05, 0, 2, bufout); // Send the data packet Serial.print("Sent Packet sequence # "); // Log action for(int i = 0; i<2; i++){ Serial.print(bufout[i]); Serial.print("\t"); } Serial.println(); delay(10 0); // slow things down }" style="color:#adbac7;display:none" aria-label="Copy" class="code-block-pro-copy-button">

// UNO - SEND & RECEIVE with CAN-BUS Module
// Tony Goodhew 24th Nov 2020
// Tutorial45.com
#include <mcp_can.h>
#include <SPI.h>

const int SPI_CS_PIN = 10;
byte len = 0;
byte bufin[8];
MCP_CAN CAN(SPI_CS_PIN); // Chip select
byte brightness = 0;  
byte sequence = 0;
void setup() {
  Serial.begin(115200);

  while (CAN_OK != CAN.begin(CAN_500KBPS)) {
    Serial.println("CAN BUS Module failed to start");
    Serial.println(" Try again");
    delay(100);
  }
  Serial.println("CAN BUS Module started."); 
}
void loop(){
  if(CAN_MSGAVAIL == CAN.checkReceive()){ // Data packet available?
    CAN.readMsgBuf(&len, bufin);          // Read data packet
    unsigned long canId = CAN.getCanId(); // Get the ID of sender
    if (canId != 0x05){                   // Is it from another node?
      Serial.println("-----------------------------");
      Serial.print("Data from ID: 0x");
      Serial.print(canId, HEX);
      Serial.print("\t");
      for(int i = 0; i<len; i++){
        Serial.print(bufin[i]);
        Serial.print("\t");
      }
      Serial.println();
      int temperature = bufin[0] - 40; // decode temperature
      int humidity = bufin[1];         // get humidity
      Serial.print("Temperature: ");   // Log to Serial monitor
      Serial.print(temperature);
      Serial.print("  Humidity: ");
      Serial.println(humidity);
    } 
  }
  // Sending:  ID = 0x05, standard frame, data len = 8, data in bufout
    brightness = brightness + 7; // Simulate turning potentiometer up
    if (brightness > 120) {brightness = 0;}
    sequence = sequence + 1;     // Increment sequence counter
    if (sequence > 255) {sequence = 0;}
    byte bufout[] = {sequence, brightness};  // Put values in output buffer
    CAN.sendMsgBuf(0x05, 0, 2, bufout);      // Send the data packet
    Serial.print("Sent Packet sequence # "); // Log action
    for(int i = 0; i<2; i++){
      Serial.print(bufout[i]);
      Serial.print("\t"); 
    }
    Serial.println();
    delay(10  0);       // slow things down
}

Things to try

Try adjusting the delays in the sketches and see what happens in the logs.
Modify the code to send floating point temperature and humidity values.
Add a real potentiometer to the UNO and use it to control the brightness of the LED on the Nano in real time.
Connect a button switch and an LED to each Arduino and try controlling the LEDs across the network.
Add an RGB LED to the Nano and control the color with three potentiometers on the UNO.
Add a display such as an SSD1306 to the Arduino to display the temperature and humidity values received.
Add a DHT22 sensor to the Nano and send real data rather than simulated.
Add additional nodes with more sensors. (If connected to the middle of the data bus they will not need jumpers on J1.)

I was very pleased to find how easy it was to get Arduinos ‘talking’ to each other with these inexpensive little boards, and I hope you will try them.

Learn How to Use a Multimeter Like A Pro

Andreea — Mon, 05 Feb 2024 16:42:49 +0000

Learn How to Use a Multimeter Like A Pro

When you begin creating your own projects, whether using a breadboard or stripboard, you may encounter more complex circuits. You might also make minor mistakes, resulting in projects not functioning as anticipated. This is when you’ll need to learn how to utilize a multimeter to assist in troubleshooting your project.

Your issues could be due to your code or your circuit. These problems could range from why a certain LED light is dim when another is fully lit, or why another LED light will not light up at all. If the issues stem from your circuit, you would likely need to use a multimeter to identify the fault. This tutorial, which is designed for beginners in electronics, will guide you on how to measure voltage, current, and resistance, as well as how to check for continuity.

Donald Macadie, a British Post Office engineer who maintained telecommunication equipment early in the 1920s, has been attributed with the invention of a single instrument that could measure amps, volts, and ohms. It was later developed and sold as the AVOmeter – Amps-Volts-Ohms. It contained a moving coil meter and precision resistors with various sockets and switches to select the appropriate mode and range. A mirror behind the needle was included to aid accurate needle readings.

This useful tool goes by several other names: multitester, or VOM (volt-ohm-milliammeter). They may be analog (with a moving needle and several scales) or digital with a numeric LCD screen. The digital meters’ lower cost and greater precision have made the analog versions obsolete.

Types of Multimeters Available in the Market

Primarily, there are two types of multimeters available in the market- Analog and Digital. The former displays measured values through a needle across a scale, while the latter uses an LED or LCD screen for the same.

Analog multimeters have been around for quite a while and are known for accuracy, the capability of reading multiple scales and reading fluctuating trends. On the other hand, digital multimeters are easier to read, more resistant to damage, and have better overall functionality. Each has its benefits, and selection depends on the user’s requirements.

The Analog Multimeter

This is a photograph of my original multimeter, bought in 1977. It still works perfectly.

It looks quite complicated with the 4 scales and 6 sets of values applied to the scales. A dial switch is used to select DC voltage (4 ranges), DC (2 ranges), Ohms, and AC voltage (4 ranges). Note the reversed logarithmic resistance scale at the top, while the others are linear, increasing from left to right.

Luckily, the new digital meters are much easier to understand and read. Most automatically select the correct range for many readings.

The prices vary from about $10 to the thousands for high-precision and accurately calibrated laboratory models. For our purpose, a multimeter priced at about $25 will do the job perfectly.

Using a Digital Multimeter

For this article, I will be using an AstroAI Digital Multimeter DT132A, which I found on Amazon for about £21. It can do all the essentials: read voltages, currents, and resistance and check continuity.

Part of a Multimeter

A modern multimeter has four parts:

Probes – insulated wires with pointed tips
Ports – where the probes plug into the meter
Controls – a rotary selection switch and buttons
Liquid Crystal Display – often with a backlight

With the meter, you receive two very well-insulated probes colored red and black. These are plugged into the meter with the black lead in COM (common) and the red probe in INPUT. They are wires with user protection/insulation and would work just as well plugged into the opposite sockets. The BLACK probe is normally connected to GND, and the RED is used to read a higher voltage.

The tips of these probes can be further exposed by removing their insulating caps. This is not recommended when working with high voltages (dangerous) or closely packed components of different heights to reduce the chances of short circuits. When taking certain readings, you may have to move the RED probe to a different port. (With this meter to measure currents > 200mA the A port should be used. Always read the manual)

We will be using the meter with very low voltages, typically 5V or 3.3V, and with very small currents, typically milliamps. Resistance could be anything from 0 to Mega Ohms.

The display starts up with a very short display of all the symbols available. Other makes and models of multimeters use the same symbols.

The third button from the left can be used to turn ON/OFF the display backlight.

The Multimeter Liquid Crystal Display

Starting at the bottom left, we have:

a battery indicator for the internal batteries used for powering the instrument, measuring resistance, and driving the LCD.
AC and the wavy line indicate Alternating Current (from a main powered wall socket – Dangerous).
Minus sign for negative values.
DC with the straight and dotted line indicates Direct Current (from a battery).
APO – Auto Power OFF – saves the internal battery – about 15 minutes.
AUTO – automatic ranging – scaling of units – volts or millivolts, etc – very useful
MAX and MIN – maximum or minimum value over time
H – hold the current value on the display
Diode Test
Continuity Test – with beep
Relative Test
Low battery indicator – change the batteries.

Unit measure

Along the bottom, we have the units being measured – left to right

Temperature in C and F, kilo, Mega, Ohm, Hz, % and micro, milli, Amps, Volts, nano, and Farads.

This model also included a K-type thermocouple for measuring temperatures. It displays ambient temperature in °C or °F without probes or thermocouples fitted.

The Difference between DC and AC

DC comes from batteries, a USB port, or a rectified power supply (direct current – always flowing in the same direction from positive to negative). AC comes from a dynamo or wall power point (alternating current which switches direction 50 or 60 times a second). It can be very dangerous because the voltage is so high and can provide high current.

Measuring the Voltage of a Battery

We turn the selector switch one click clockwise from OFF to DC voltage (V with a straight line). The RED probe is pressed to the positive end of the battery and the BLACK probe to the negative end. The voltage is shown, automatically scaled to indicate this battery is only supplying 1.199 volts and should be replaced.

To read a voltage we put the meter in parallel with the object we are measuring the voltage difference across.

If we try a different battery, but put the probes on the wrong ends we get a negative reading but the absolute value is correct.

Trying again with an old 9V battery.

I picked the wrong terminals again but the unsigned value is correct.

Notice the AUTO in the top left corner showing that auto ranging is ON. The display was showing millivolts at start-up but quickly changed range automatically.

With auto-ranging, the display may take a short time to settle. This is well worth the short delay and is quicker and easier than having to select a different range manually. APO showing indicates that it will Auto Power OFF to save the meter’s internal battery if I forget to switch it off. This takes about 15 minutes so it is good practice to turn the selector switch back to OFF as soon as you have taken the reading.

Reading AC voltages

Turn the rotary selector one more click clockwise to select Alternating Current (V with a wavy line). This is also auto-ranging but starts with Volts.

If you really need to check the AC voltage at a wall socket (this is dangerous so I do not recommend it) just turn the selector switch to the second position (HzV~) and use the probes very carefully on the live and neutral sockets. Keep your fingers well away from the metal tips of the probes

Measuring Resistance

Turn off and disconnect circuit before checking

In the past I have found a pair of insulated croc-clip wires extremely useful, especially when reading the values of resistors. If you are colour blind, or do not trust yourself to remember the colour codes, it is very easy to find the value of a resistor with your meter. Turn the selector switch to the Ω – Omega – Ohms position. The value will appear on the screen. This one is shown as 0.665 K Ohms = 665 Ohms. The colours were blue, grey, brown – 680 Ohm – within stated tolerance.

If you do not have croc-clip wires just use fingers and thumbs to pinch a probe to each end of the resistor wires. If you are measuring a resistor already in a circuit you must turn the power off before measuring.

Checking Continuity

Turn off and disconnect circuit before checking

This is related to resistance. Good continuity has very low to zero resistance – the current flows without resistance. If you turn the selector to the resistance position (4 clicks from off) the display should show 0.L M Ω (Overload), indicating massive resistance or no connection.

If you then touch the ends of the probes together the display will change to zero or 0.1 Ohm indicating no resistance or very good continuity – a good connection. To save you having to keep looking at the screen as you probe a circuit board, checking if certain pins are properly connected, you can get the meter to beep if there is good continuity. Select resistance with the rotary switch and press the select button until the continuity symbol appears on the screen and the meter beeps.

Check by touching the ends of the probes together to get a beep. Hold the probes against the opposite ends of a suspect length of wire. If you get a beep, continuity is good. If the meter remains silent the cable is broken at some point. (This meter will beep if the resistance is less than about 30 Ohms. If you want a really good indication, read the resistance rather than listen for a beep. I have another meter which has a beep threshold of 120 Ohms. Check your manual to find the threshold value for your instrument.)

This facility is very useful if you have just had to solder a set of pins onto a new microcontroller board such as an ESP 32 or a small Arduino board. You need to check that there is no continuity between adjacent pins because too much solder has flowed and you have bridged them. Here you set up the meter for continuity and press the probes on the top of each pair of adjacent pins in turn. If you have done a good job you should not get a beep.

In a similar manner you can check for a required good connection between a pin on your microcontroller and the leg of a component on a circuit board. (There may be a dry joint or a wrongly positioned cut of a copper track on your board upsetting the connection.)

Adjacent copper strips on stripboard circuits should not normally be connected. You can use continuity to check for solder blobs bridging adjacent strips or poorly made breaks in strips, allowing current to flow in the wrong place.

Reading Current

To read a current your meter must be inserted into the circuit in series rather than in parallel. Your meter becomes part of the circuit, replacing a connection wire. On a breadboard circuit, this is quite easy to accomplish by replacing a single jumper wire with two and inserting the meter in the join. On a stripboard or printed circuit board, you have to cut a track and insert test point pins for the meter, which can later be joined with a jumper connection once the meter has been removed.

When connecting the meter, you should consider the direction of the current flow. The RED probe would normally be connected to the higher potential. For example, to read the total current flowing through a circuit, break the GND return wire, and connect the BLACK probe nearer to the GND pin on the Arduino and the RED probe towards the circuit board. If you get the polarity wrong you will get a negative reading.

My meter has three selection positions on the dial for reading current, µA, mA and A. If you expect the current to be greater than 200 mA the RED probe has to be moved from the normal INPUT socket to the A socket, which has a higher rated fuse, and use the A selection on the dial. We will be expecting less than 200 mA, so we can leave it in the INPUT socket and select mA. Check that it defaults to DC.

A Practical Example Project

I’m going to build a simple circuit and read the resistance, and then current and voltage change while it is running. This is a very simple build including a button switch, an LED and two resistors, 10K and 560 Ohm.

This circuit shows a 680 Ohm where I used a 560 Ohm resistor, on the right, between the LED and GND. (Fitzing did not have a 560 Ohm resistor available in the bin.)

I had previously built it on a stripboard.

With the circuit not connected to the Arduino, I measured the resistance of the resistors and got 9.89K Ohms for the 10K and 554 Ohms for the 560 Ohm resistor. (Remember that resistors have a tolerance of 5% or 10%. These were both within tolerance) The probes were pressed to the wires at either end of the components.

I connected the circuit to the Arduino and ran the following simple script which switches on the LED when the switch is closed. A pull-down 10 K ohm resistor was used so that the switch value was TRUE (1) when pressed. The LED, green wire, was connected to pin 9 and the switch, yellow wire, was connected to pin 8 of the Arduino UNO.

// Multimeter Circuit Testing Project  
// Tony Goodhew - 12 Aug 2020
// Tutorial45.com
// LED with 560 Ohm resistor on pin 9
// Button switch with 10K Ohm pull-down resistor on Pin 8

int LED = 9;     // Green wire
int button = 8;  // Yellow wire

void setup() {
  pinMode(LED, OUTPUT);
  pinMode(button, INPUT);
}

void loop() {
  int button_Value = digitalRead(button); // Read button
  digitalWrite(LED, button_Value);        // Adjust LED
  delay(50);                        
}

Resulting Measurements

The voltage between the 5V and GND pins was 4.99V without the board connected and this dropped to 4.98 V when the board was connected and the switch open or closed.
The voltage dropped across the 10K Ohm pull-down resistor was 4.98 V as the switch was closed.
With the script running the voltage drop across the 560 Ohm LED resistor was 2.264 V when the LED was ON.
To measure the current flowing through the LED and the 560 Ohm resistor, I put the meter between pin 9 (RED probe) and the green wire (BLACK probe) and found that the current was 4.09 milliamps.
To measure the current of the whole board I put the meter between the black wire (RED probe) and the Arduino GND pin (BLACK probe) and got 4.59 milliamps.
An LED is a diode so with the circuit unpowered and disconnected from the Arduino I put the RED probe on the end of the green wire, LED anode, and the BLACK probe on the cathode of the LED, then selected the diode option with the selection switch and button. The reading was 2.299 V – approximate forward voltage of the LED.

Conclusions

I have always found access to a multimeter very useful. How do I use it?

Checking the state of batteries – OK, recharge, or replace?
Checking the value of resistors before I solder them in place.
Continuity checking after soldering or fault-finding. Is there a good connection between these two points?
Eliminating unwanted connections because of an excess of solder or poor copper strip cutting when making, or forgetting to make, an essential break in a track.
I hardly ever measure a current.

Final Thoughts

The instruction manual that comes with your meter is a vital source of information, and you should read it carefully in case your meter differs slightly in its ways of working from mine. (Why is the print always so small? This is much easier to read: https://static.astroai.com/manual/Astroai-Digital-Multimeter,-Trms-4000-Counts-User-Manual.pdf so download a pdf version of your manual, if available.)
Be very careful when working with 120 or 240V AC. It can KILL!

Arduino MOSFET Project

Nikodem Bartnik — Tue, 16 Jan 2024 07:32:07 +0000

Arduino MOSFET Project

If you’re familiar with Arduino, you’re likely aware of the frequent need to incorporate motors into projects, especially those involving robotics. In a previous tutorial, we discussed using a transistor to control small motors. But what if you find yourself needing to control a larger motor? The solution to this requirement lies in using a MOSFET. As defined by Wikipedia:

A type of field-effect transistor (FET). It has an insulated gate, whose voltage determines the conductivity of the device. This ability to change conductivity with the amount of applied voltage can be used for amplifying or switching electronic signals.

Put simply, a MOSFET is a specific type of transistor that employs a Gate rather than a Base (contrary to the bipolar transistor). Notably, the Gate in a MOSFET is isolated, rendering it considerably safer for use with Arduino. While there is more to the intricacies of MOSFETs, we won’t delve into those details in this session. For our purposes, we’ll be working with the IRF44N MOSFET, a highly economical and widely used field-effect transistor.

Arduino Mosfet

Here is the list of parts we will need for this project:

You can use any other transistor, check out its pinout and datasheet to ensure that it can be used with the rating needed for this project.

If you have all of the components that we need, you can connect them using the schematic below.

To power this circuit, we need an external power supply of 12V, but a 9V should be ok as well. You can connect it to Arduino with the DC jack.

It is very useful to use cables with crocodile clips to connect jumpers to the motor; they will hold safely and help you avoid soldering.

We can use the analogWrite function to control the motor speed with a PWN signal.

If you use a relay to control your motor, you will not be able to control it with the PWM signal. Relay responses will be too slow for such applications.

The code will increase the motor speed, slow it down, and do that over and over again. Here is the code:

As you can hear, when it is not moving, it makes odd sounds. That’s because of the current that flows through the motor coils.

And here we go! Don’t hesitate to comment below if you need further information about this project.

Feel free to check other projects here.

Arduino Communication With the nrf24L01

Andreea — Sun, 21 Jun 2020 22:24:25 +0000

Arduino Communication With the nrf24L01

At some point, most Arduino owners will decide that their next project requires communication between two of their microcontroller boards. You might want to control a long strip of NeoPixels decorating your room from the comfort of your armchair without tripping over cables or read the temperature and humidity of your greenhouse without putting on a coat and wandering up the garden. Another use may be to control a floor robot from a handheld home-built controller with a joystick and buttons. This article explains how to set up two Arduinos with nrf24L01 transceiver modules so that they can ‘talk’ to each other and provides a starting point for such projects.

In this piece, I’m going to explain what the nrf24L01 does and how it is connected to your Arduino. I’ll also compare a couple of alternative devices and then move on to two small demonstration projects.

The NRF24L01

This is a radio Transceiver (it both transmits and receives) which operates on the 2.4 GHz Industrial, Scientific and Medical bands. It has a very good range, low power consumption, is cheap to buy, readily available and has several Arduino libraries available. Nordic call it a 6 data pipe MultiCeiver because it can listen to up to 6 other devices at once and transmit to them one at a time.

It can transmit at 250bps, 1Mbps and 2Mbps on-air rates with a choice between 125 channels (1 … 125). The board contains a transceiver chip from Nordic Semiconductor, a crystal, an antenna, a few support components, and 8 connection pins. The user can adjust the power of the transmission to one of four levels, (MIN, LOW, HIGH, and MAX) depending on the range required. Possibly up to 100m outdoors. There is an on-chip voltage regulator that needs a supply voltage of between 1.9 and 3.6V on the VCC pin. It is a 3V device and the VCC pin must not be connected to 5V. The other logic input pins are 5V tolerant which makes things much easier.

The main downside is that the connection pins on the underside of the board are breadboard hostile. (The 2×4 arrangement of the pins would short out connections.) You have to use Dupont jumper wires to connect it up to an Arduino. Recently a 5V small shield board has become available which drops the voltage from 5V on your Arduino to 3.3V for the nrf24L01. It has an LED to indicate it is receiving power and the connection pins have labels. (More on using the NRF24L01 Wireless RF Transceiver Socket Adapter Board with 3.3v Regulator later but if you have not yet bought your nrf24L01s I suggest you pick up shields at the same time.)

This chip automatically carries out the assembly of a data packet, its transmission and the checking of an acknowledgement reply from the receiver. It can automatically try resending the data (15 times is the default) if there was an error highlighted by the CRC check on the data received or no ACK received. Nordic call this “Enhanced ShockBurst”.

Each packet is made up of:

Preamble	Address	Packet Control Field	Payload	CRC
1 byte	3 – 5 bytes	9 bytes	0 – 32 bytes	1 – 2 bytes

The documentation for the chip can be found here:

I found it very interesting and am thankful that several generous people have shared their Arduino libraries for our benefit. The work involved must have been considerable. You get a great deal of Bang for your Buck with these boards.

Other devices you might consider:

433 MHz General RF receive and send pairs

These are cheap, very basic, but no longer so readily available as more modern alternatives. The more recent drivers/libraries than the early VirtualWire library such as Radiohead are better but still have quite a steep learning curve. You have to build your own packets of data, add identifiers to your packet information, and carry out acknowledgment data of packets and any integrity checking. The soldered-on antenna wires get in the way. I have had success with these in the past. These are in a similar price bracket to the nrf24L01.

Bluetooth

This system is now increasing in popularity, but it will seldom be an inexpensive route. There is currently a great deal of ongoing development and you can easily connect to your phone/tablet via free downloadable apps. Adafruit have included the BLE technology in many of their boards which are Arduino IDE and CircuitPython compatible. I’ve used CircuitPython, but not Arduino, on these devices and found them quite simple to set up. If you want an official Arduino with radio you could try an Arduino Nano 33 IoT or Arduino MKR WiFi. Unfortunately, the range of BLE (Bluetooth Low Energy) devices is quite short.

After looking at these three possibilities the nrf24L01 system would appear to be the most versatile and cost effective.

Connecting up an Arduino with nrf24L01

This is a Serial Peripheral Interface (SPI) device and has eight pins. We will need M-F DuPont cables to make the connections to an Arduino.

Looking at the top of the device and working round clockwise from the top right, orange pin

Wire	Pin name	UNO pin
Orange	VCC – 3V NOT 5V	3V
Yellow	CSN	8 or other
Green	MOSI	11 SPI
Silver	IRQ	Not connected
Grey	MISO	12 SPI
Purple	SCK	13 SPI
Blue	CE	7 or other
Black	GND	GND

Unfortunately, this uses up the built in LED on pin 13.

Other Arduino boards, such as a Mega or Piksey Atto have their SPI connections (MISO, MOSI & SCK) on different pins. Please check before connecting up if you are not using an UNO.

Be very careful not to connect VCC to 5V as this will kill the radio chip. We will need to set up two Arduinos with their RF24s. On one of the Arduinos, I have also installed a 10K Ohm potentiometer to provide a variable input for the projects.

The next step is to install the RF24 library. Start the Arduino IDE. Go to Tools 🡺 Manage Libraries… Type ‘RF24’ into the top right box and press . There are several different libraries available so scroll down to the one ‘by TMRh20 version 1.3.4’ and then click on install. This one is said to be simple for beginners and has plenty of examples. You can find the examples from the menu via File 🡺 Examples 🡺 RF24. They are long, well-spaced and with plenty of comments.

Test the setup

The first example tests that we have all the items set up correctly. It demonstrates a simple, one-way transmission of a single integer from one Arduino to another, (a ‘Boss’ and ‘Subordinate’ setup) and we can check that we understand the basics, everything is connected together properly and working reliably. The second will allow two-way communication with multiple values transmitted between them.

Project #1: Display the value from a potentiometer on one Arduino on the Serial Monitor of another Arduino.

Components required

2 Arduinos with USB cables
2 nrf24L01s
1 10K Ohm potentiometer
Breadboard or stripboard
DuPont cables (M-F) and connecting wire

Assemble the components as shown in the previous Fritzing schematic.

We now need to connect our Arduinos to our PC so that we can program them with the Arduino IDE. The Arduino on the right side of the desk, with the potentiometer (‘Boss’), is going to send data to the other Arduino on the left side of the disk (‘Subordinate’). Start up the Arduino IDE, drag it to the right-hand side of your screen and plug the ‘Boss’ into the right most available USB port. Set the board type, check the port you are using, mine was COM 29.

Start another instance of the Arduino IDE, directly from the Start Menu. Do not open another window from the File menu of the first instance. Plugin the ‘Subordinate’ Arduino to the leftmost USB port. Drag this editor window to the left side of your screen, Look in Tools 🡺 Port and you should see two ports listed. Select the new port. Mine was COM 27.

This does not always work the first time but it is essential that both instances of the Arduino IDE have different ports.

Copy and paste the first script into the Boss and second into the Subordinate. Compile both scripts, upload and open the Serial Monitors and adjust the baud rate if necessary. As you twist the top of the potentiometer you should see the value change in both monitor windows.

Send Test script for Arduino with Potentiometer

// 'Boss' computer sending messages to 'subordinate' via nrf24L01
// File name: Send_Test paired with Received_Test - Tony Goodhew 17 June 2020
#include   
#include "RF24.h"

RF24 myRadio (7, 8);      // These can be changed CE, CSN
byte addrs[][6] = {"T"};  // Data pipe to send on
int potPin = A0;          // 10K Ohm pot for changing input

void setup() {
  Serial.begin(115200);                  // Start Serial Monitor
  delay(1000);
  // Set up the radio
  myRadio.begin();                       // Start radio
  myRadio.setChannel(100);               // Could be changed 1 ... 125
  myRadio.setPALevel(RF24_PA_MIN);       // Power level minimum - radios are close together
  myRadio.setDataRate( RF24_250KBPS );
  myRadio.openWritingPipe( addrs[0]);    // Write to pipe called "T"
  delay(750);
}

void loop() {
  // Get current values
  int potValue = analogRead(potPin);   // Read Pot value
    
  // Send the packet of data called data1 to Subordinate
  myRadio.write(&potValue, sizeof(potValue));   

  // Report sent values to Monitor
  Serial.print("Sent: ");
  Serial.println(potValue);
  delay(800);
}

Additional notes

At the top we include the necessary libraries, initialise myRadio by providing the pin numbers for CE and CSN and tell the script where the potentiometer is connected.

In the setup routine:

We start the Serial Monitor at 115200 baud, and select the settings for the radio:
Channel at 100 (Any value from 1 to 125)
Power of transmission MIN, (LOW, HIGH or MAX) as both transducers are close together
DataRate 250KBPS (1MBPS or 2MBPS)
Open the WRITE pipe: “T”
Pause for this to be set up

In the loop:

Read the value of the potentiometer
Write the potValue and its size(bytes) to the radio
Print the potValue to the Serial Monitor
Short delay

Receive test for Arduino without potentiometer

// 'Subordinate' receiving messages from 'Boss' via nrf2401
// File name: Receive_Test to be paired with Send_Test - Tony Goodhew 17 June 2020
#include   
#include "RF24.h" 

RF24 myRadio (7, 8); 
byte addrs[][6] = {"T"}; // Data pipe
int x = 0;               // Variable to hold received data

void setup() {
  Serial.begin(115200); // Start Serial Monitor
  delay(1000);
  // Set up the radio
  myRadio.begin();                       // Start radio
  myRadio.setChannel(100); 
  myRadio.setPALevel(RF24_PA_MIN);       // radios are close together
  myRadio.setDataRate( RF24_250KBPS ); 
  myRadio.openReadingPipe(1, addrs[0]);  // Read from pipe called "T"
  myRadio.startListening();              // Listen for signal from Boss
}

void loop()  {
  if (myRadio.available()) {
    while (myRadio.available()) {         // Picked up transmission from Boss
      myRadio.read(&x, sizeof(x));     // Get the values from radio buffer
    }
    // Print package contents to Monitor for checking
    Serial.print("Received: ");
    Serial.println(x);
  }
}

Additional Notes

The first part mainly matches the sending script but we initialise an integer variable x to receive the value being sent from the pot.

The setup sequence is similar but we need to open a READING pipe. Note the additional 1 in the brackets. We then start listening for a radio signal.

The main loop waits for a radio signal, reads the value sent, stores it in the variable x and prints it to the Serial Monitor.

Now we have this working we can take the complexity up a notch. If you cannot get this to work look at the end of the article for additional help with problems.

Project #2: Send multiple data items in a packet using Arduino with nrf24L01

The basic outline is the same but we have to send multiple values, of different types in a packet called data1. I have included two integers, a floating-point value and a message string. Twist the knob on the potentiometer to change the values sent.

Script for the transmitting from the Arduino board with the potentiometer on A0

// 'Boss' computer sending messages to 'subordinate' via nrf24L01
// File name: RF_send3 paired with RF_receive3 - Tony Goodhew 17 June 2020
#include   
#include "RF24.h"

RF24 myRadio (7, 8);      // These can be changed CE CSN
byte addrs[][6] = {"T"};  // Single data1 pipe to send on
int potPin = A0;          // 10K Ohm pot for changing input

struct package {        // Define the data1 packet contents
  int pktNo = 0;        // Count and identify packets sent
  int rawPot = 0;       // 0 .. 1023 from 10K Ohm potentiometer
  float perCent = 0.0;  // floating point value
  char msg[50] = "Here is a MESSAGE";  // Text string - Not changing
};
typedef struct package Package;  
Package data1;   // Package named data1 contains pktNo, rawPot, perPot, perCent & msg

void setup() {
  Serial.begin(115200);                  // Start Serial Monitor
  delay(1000);
  myRadio.begin();                       // Start radio
  myRadio.setChannel(100);               // Could be changed 1 ... 125
  myRadio.setPALevel(RF24_PA_MIN);       // Power level minimum - radios are close together
  myRadio.setDataRate( RF24_250KBPS );
  myRadio.openWritingPipe(addrs[0]);    // Write to pipe called "T"
  delay(750);
}

void loop() {
  // Get current values
  int potValue = analogRead(potPin);   // Read Pot value
  data1.rawPot = potValue;             // Put changed values into next packet
  data1.perCent = potValue * 100.0 / 1023.0;  // FP value
  data1.pktNo = data1.pktNo + 1;
  
  // Send the packet of data called data1 to Subordinate
  myRadio.write(&data1, sizeof(data1)); 

  // Report sent values to Monitor
  Serial.print("\nPackage Sent:");
  Serial.println(data1.pktNo);
  Serial.println(data1.rawPot);
  Serial.println(data1.perCent);
  Serial.println(data1.msg);           // array of chars
  delay(800);
}

Script for the receiving with the Arduino board using nrf24L01

// 'Subordinate' receiving messages from 'Boss' via nrf2401
// File name: RF_receive3 to be paired with RF_send3 - Tony Goodhew 17 June 2020
#include   
#include "RF24.h" 

RF24 myRadio (7, 8); 
byte addrs[][6] = {"T"}; 

struct package  {  // Items and order must match packet being sent by 'Boss'
  int pktNo = 0;
  int rawPot = 0;
  float perCent = 0;
  char msg[50] ="_";
};
typedef struct package Package;
Package data1;  // Package named data1 contains pktNo, rawPot, perPot, perCent & msg

void setup() {
  Serial.begin(115200); // Start Serial Monitor
  delay(1000);
  myRadio.begin();                       // Start radio
  myRadio.setChannel(100); 
  myRadio.setPALevel(RF24_PA_MIN);       // radios are close together
  myRadio.setDataRate( RF24_250KBPS ); 
  myRadio.openReadingPipe(1, addrs[0]);  // Read from pipe called "T"
  myRadio.startListening();              // Listen for signal from Boss
}

void loop()  {
  if (myRadio.available()) {
    while (myRadio.available()) {           // Picked up transmission from Boss
      myRadio.read(&data1, sizeof(data1)); // Get the values from radio buffer
    }
    // Print package contents to Monitor for checking
    Serial.print("\nPackage Received:");
    Serial.println(data1.pktNo);
    Serial.println(data1.rawPot);
    Serial.println(data1.perCent);
    Serial.println(data1.msg);
  }
}

Project #3: Send data in both directions to operate hardware using Arduino with nrf24L01

Additional components

2 LEDs
1 Button switch
2 560 Ohm resistor or near match to protect LEDs
1 10K Ohm resistor – pull-down resistor

Add an LED and 560 Ohm resistor to pin 3 of each Arduino. We need to use pin 3 because that has pulse-width modulation so that we can adjust the brightness.

Add the button switch and 10K Ohm pull-down resistor to pin 2 of the Arduino without the potentiometer.

These scripts should allow each Arduino to control the LED on the other Arduino. The potentiometer will control brightness/fading and the button switch will turn the other LED ON/OFF.

Here are the scripts:

// Potentiometer End
#include 
#include 
RF24 myRadio(7, 8);

byte addrs[][6] = {"T","G"};
int led = 3;  // LED on pin 3 and 10K Ohm on pin A0

void setup() {
  Serial.begin(115200);
  Serial.println("Starting...");
  pinMode(led, OUTPUT);
  myRadio.begin();  // Start the Radio 
  myRadio.setPALevel(RF24_PA_MIN); // Close together so low power
  myRadio.setDataRate(RF24_2MBPS); // High speed
  myRadio.setChannel(99);
  myRadio.openWritingPipe(addrs[0]);     // Open data pipes
  myRadio.openReadingPipe(1, addrs[1]);  // Opposite way round on other Arduino

  myRadio.startListening();  // Listen for a signal
}
// ============ Main Loop ============
void loop() {
  int dataIn = 0; // Received value - button 1/0
  int dataOut = 0;  // Value to send - from pot - brightness

  if (myRadio.available()) { // Has a signal arrived?

    // Get value and update LED
    while (myRadio.available()) {
      myRadio.read( &dataIn, sizeof(dataIn));
      digitalWrite(led, dataIn); // update LED
    }

    myRadio.stopListening();  // Stop listening
    dataOut = analogRead(A0); // Get value from Potentiometer
    myRadio.write(&dataOut, sizeof(dataOut) ); // Send Raw pot value ( 0 ... 1023)

    myRadio.startListening();  // Resume listening for next pass through loop
  }
}

// Button End
#include 
#include 
RF24 myRadio(7, 8); // Setup radio

byte addrs[][6] = {"T", "G"};
int button = 2; // Button switch on pin 2
int led = 3;    // LED on pin 3

void setup() {
  Serial.begin(115200);
  Serial.println("Starting...");
  pinMode(button, INPUT);
  myRadio.begin();  // Start the Radio
  myRadio.setPALevel(RF24_PA_MIN);  // Close together so low power
  myRadio.setDataRate(RF24_2MBPS);  // High speed
  myRadio.setChannel(99);
  myRadio.openWritingPipe(addrs[1]);     // Open data pipes
  myRadio.openReadingPipe(1, addrs[0]);  // Opposite way round on other Arduino
}
// ============ Main Loop ============
void loop() {
  int dataOut = digitalRead(button); // Get button data to send
  myRadio.stopListening();           // Stop listening - we need to send

  if (! myRadio.write(&dataOut, sizeof(dataOut) )) {
    Serial.println("No ACK ");    
  }

  myRadio.startListening(); // Listen for signal
  unsigned long startTime = millis(); // Record current millisecond time

  // Get an ACK signal OR timeout - We cannot wait forever
  while (! myRadio.available()) {
    if (millis() - startTime > 150 ) { // Have we waited long enough?
      Serial.println("Timeout! No response");
      return;
    }
  }

  int dataIn = 0;  // To hold received value
  myRadio.read( &dataIn, sizeof(dataIn) ); // Get the RAW brightness for the LED
  analogWrite(led, dataIn / 5);            // Update LED brightness – never max
  delay(100); // Short delay for quick reaction
}

Copy, paste, compile and upload both scripts. Twisting the knob on the potentiometer should change the brightness of the LED on the other while closing/opening the button switch should turn the other LED ON/OFF.

There are plenty of comments in the scripts to help you understand how they are working.

Conclusion

By this point, you should have some idea about the usefulness of these small and inexpensive radio boards and be ready to modify the code I’ve provided to make your own project.

Some project suggestions

Use 3 potentiometers on A0, A1, and A2 to control the color of a common cathode RGB LED on the other Arduino. You can use pins 6, 5, and 3 as they are all PWM pins and a single 560 Ohm resistor on the common cathode to connect to GND
Connect a Joystick to one Arduino and use it to set the speed and direction of the motors on an Arduino controlled floor buggy. You could add buttons to control LEDs or a Neopixel strip
Use temperature, humidity, and air pressure sensors to send current readings from your garden shed to another Arduino fitted with an OLED SSD1306 or LCD display
Look at the examples provided with the RF14 library. They include a few more statements not covered in this piece.

Problems

Using 2 Arduinos at the same time in a project more than doubles the number of things that can go wrong. You have two scripts to debug, 2 sets of hardware, and no easy way to check that your radios are working. It is very easy to update the code on the wrong Arduino when you have 2 instances of the IDE on the screen at the same time. I always keep the windows to the left and right of the screen matching the positions of the Arduinos on my desk and regularly check the ports at the bottom right of the IDE windows before uploading.

I was using a ‘proper’ UNO R3 and a Sparkfun RedBoard UNO R3 clone while developing this article. The one-way demos worked perfectly but as soon as I added the extra components I could not get them to ‘talk‘ to each other. I eventually ordered some of the NRF24L01 Wireless RF Transceiver Socket Adapter Boards with 3.3v Regulators.

I installed one on the RedBoard and at once everything started working. It would appear that adding the extra components reduced the power available on the 3V pin below the level needed to operate the radio successfully. Using the power from the 5V pin, through the 3.3V regulator on the adapter board, supplied enough power. These extra boards also have a power indication LED and all the pins have labels making the correct connection easier.

A Review of the Grove Beginner Kit for Arduino

Andreea — Sat, 06 Jun 2020 11:00:00 +0000

A Review of the Grove Beginner Kit for Arduino

Anyone interested in developing electronics hardware and dabbling in IoT is recommended to start with Arduino projects. This is because the average Arduino kit opens your mind up to the possibilities of building unique ideas from scratch with just a board, soldering tools, and electronic components. The Grove Beginner Kit is one such tool that helps you get started with Arduino. Here, its features, capabilities, and applications will be discussed in detail.

The Features of the Grove Beginner Kit

The Grove beginner kit comes with the following items:

An Arduino UNO Compatible board (ATmega320p)
A micro USB cable
Grove cables
LED light
Buzzer
OLED Display
Buttons
Rotary Potentiometer
Light sensor
Temperature sensors
Humidity sensors
Air Pressure sensor
3-axis Accelerator
Seeeduino Lotus – The Arduino compatible board

The LED and lighting features are simple modules that provide light when assembled with the Arduino board. The light sensor functions y detecting the intensity of ambient light while the temperature sensor provides support for detecting temperature levels of surroundings. The humidity sensor measures humidity level and air pressure sensors measure air pressure.

Other important components within the kit such as the OLED display serve as a display or visualization screen which does not consume much energy. The buzzer produces a buzzing sound while buttons and cables are supportive components for controlling your project.

Getting Started with the Grove Beginner Kit

The Grove Beginner Kit also comes with instructions on how to get started and different Arduino projects you could accomplish using the kit. To get started, you will need to install the Arduino integrated development environment (IDE) on your laptop or desktop computer. You will need a functional Arduino IDE for installing and configuring every component you intend to use for your projects.

Once the Arduino IDE is installed, the next step is installing the USB driver which connects Arduino and your project to your computer. Once connected, you can now create new files for your programming requirements. As stated earlier, the Grove beginner kit includes simplistic steps for getting started. This means you do not need to have any prior knowledge of Arduino and electronics to use this kit.

The Grover kit also comes with a dedicated wiki page for anyone interested in learning the basics of electronics, programming, and configuring DIY electronics or IoT projects. Within this dedicated page, information such as definitions of a digital signal, code analysis, etc. will be provided. You can also take advantage of the lesson guides about developing your projects with the Grove beginner kit.

Projects You Can Do with the Grove Beginner Kit

Experienced electronics and hardware technicians or hobbyists will have some idea of what can be developed using the components of the Grove kit. But for beginners, here is a list of exciting projects to get you started with DIY electronics:

Blinking LED – The blinking LED project involves getting the LED light to come on and off at the touch of a button or in intervals. This means you can get the LED light to light up at intervals, at the touch of a button, or increase the intensity of the light it produces. The components you will need for this project include the Seeeduino Lotus, the Grove LED lights, button, and cables. The software code for the project can be found within the wiki page; you can simply copy and paste the code into your Arduino IDE or study the analysis behind the code to learn more about programming with Arduino.
Buzzing the Buzzer – The Buzzer is an output module that produces a buzzing sound when configured using the components within the Grove kit. You can choose to modulate the sound it produces in diverse ways according to your needs. The components you will need for this project include the Seeeduino Lotus, the Buzzer, grove cables, and the button. The potentiometer is also required for adjusting the volume that comes from the buzzer. To accomplish these tasks, you will need to program the buzzer, potentiometer, and the button. You can also find the information or code needed to program the buzzer within the wiki guide provided for the Grove beginners kit.
Smart Lighting – The inclusion of a light sensor means you can develop a LED light that automatically lights up once placed in a dark place. This means, our Arduino project must be able to sense the intensity of ambient light and send the information to Arduino which lights up the LED to illuminate the room with adequate intensity. For this project, you will need the Seeeduino Lotus, Grove LED light, light sensor, and cables. The code for the smart lighting project can be found within the kit’s wiki page.
Visualizing Data on OLED – The OLED display provided with the Grove kit was included to help you take readings from the sensors included in the kit. Thus, if you hook up the temperature or humidity sensors, you will need to take readings and the OLED display provides the avenue for doing this. The components you will need for this project include the Seeeduino Lotus, OLED display, grove cable. Note that these components are needed solely for integrating the OLED display into your project. To read temperatures, you will also need to configure the temperature sensor. You can find the codes needed for this project within the wiki page including the description of each snippet of code.
Temperature and Humidity Detection Device – The Grove kit for beginners comes with the components you need to create a mini-weather station. The station will be able to detect humidity and temperature while displaying its readings on the OLED display. The tools you will need for this project are the Seeeduino Lotus, OLED, temperature and humidity sensor, and Grove cables. This is a more advanced Arduino project but you can find the details for it within the wiki page. The temperature and humidity detection device also helps you expand your knowledge of combining multiple sensors onto a single board.

The Grove Beginners Kit cost approximately $20 which is very affordable for students and anyone interested in learning about electronics, IoT, and programming hardware.

Arduino Projects Archives - Tutorial45

Charlieplexing LEDs With The Arduino Board

Project #1 – 6 LEDs on 3 wires

Required materials

Project #2 – 12 LEDs with 4 wires

Things to try

Conclusion

Arduino to LCD projects – Using 3 Different Types of LCDs

The Technology

The Display Modules

MakerHawk OLED displays with SSD1306 driver chip

MakerHawk 12C OLED display with 128×64 (blue)

MakerHawk 12C OLED display with 128×32 pixels (white)

Project #1: Using Arduino with the LCD 128×64 pixel SSD1306 board

Project #2 Using the Arduino with the LCD SSD1306 128×32 pixel board

Conclusion

Suggested projects

AZ-Delivery HD44780 2004 LCD Display Bundle 4×20

Project #3 Using Arduino with the AZ-Delivery LCD 2004 and FC-113 I2C backpack

Materials needed

Conclusion

Project suggestions

Comparing the boards

Overview

Nokia 5110 Arduino Project From Start to Hero

Nokia 5110 Arduino Project with the AZ-Delivery with PCD8544 84×48 Pixel LCD Display

Conclusion

Additional things to try:

Hint

Arduino Touch Screen Project

Color picking

Using the SD card reader

Using the Touch Layer

Conclusion

Alegoo Super Starter Kit and UNO R3 Project Reviews – Gift Guide

Components in the Elegoo UNO Project Super Starter Kit

Getting Started with the Elegoo UNO Project Super Starter Kit

Lessons You Should Take Advantage of with the Super Starter Kit

And what do the lessons cover?

Sample Tasks to Consider Doing with the Elegoo UNO Project Super Starter Kit

The Ultrasonic Distance Measurement Project

Joystick Control of a DC Motor

Conclusion

Mcp2515 Arduino Project: Using a Controller Area Network (CAN) with Arduino

The fields of a standard CAN frame

System Test

Connections

Library

Basic SEND sketch

Basic RECEIVE sketch

Project: Sending data both ways

Nano Code

Uno Code

Things to try

Learn How to Use a Multimeter Like A Pro

Types of Multimeters Available in the Market

The Analog Multimeter

Using a Digital Multimeter

Part of a Multimeter

The Multimeter Liquid Crystal Display

Unit measure

The Difference between DC and AC

Measuring the Voltage of a Battery

Reading AC voltages

Measuring Resistance

Checking Continuity

Reading Current

A Practical Example Project

Resulting Measurements

Conclusions

Final Thoughts

Arduino MOSFET Project

Arduino Mosfet

You might also like:

Arduino Communication With the nrf24L01

The NRF24L01

433 MHz General RF receive and send pairs

Bluetooth

Connecting up an Arduino with nrf24L01

Test the setup