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:

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

//  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

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.

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

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

Today, we are going to build a DIY metal detector with the help of these devices which will help make the process easy and fun. The end product, the metal detector itself once built can help you find metallic stuff under the ground, who knows what might just be buried there waiting for you!

Here are the items included in the Box:

There are components like transistors and resistors which can look identical though there are not.

Fortunately enough, everything is labeled on the PCB. We should not have any issue with the assembly of this kit.

Let’s start with all of the capacitors, those are of orange, big black, and green color. Make sure that polarities of the biggest black capacitor match with PCB.

Solder everything and cut out the legs of each component.

Now we have to put the two resistors in place, each of them has a different value one is 2.2k and the other is 220k. You can measure that with a multimeter. If you don’t have a multimeter make sure that it looks the same as on the image below. (You can learn how to use a multimeter here)

Solder everything and cut off the legs of both resistors.

Now we have three transistors. They are different from one another, we have a 9018, 9015 and 9012. There are labels on the PCB with exactly the same way. Simply put them in their proper place on the board.

In the end, we can solder the potentiometer, buzzer, and 2 cables.

Make sure that the positive pin of the buzzer is where there is + on the PCB. The holes for power cables are labeled with + and -.

And here you go!

To power it up, you can use anything in the range of 3 to 5V. I am using my adjustable power supply with the voltage adjusted to 4V.

You can also use normal AA or AAA batteries and use it remotely to find some treasures outside if you are into this kind of thing.

We worked on creating a decibel meter using the Arduino board here and how to assemble an audio level indicator. This one is a simple and perfect electronic project for beginners.

Let’s put this voice control LED board together so the LEDs blink every time noise is detected.

Let’s get started.

Here are the elements contained in the set.

Apart from the part shown in the image above, we will need a soldering iron and a solder.

The 3 resistors here have different values. To find out which one is which, remember you can use a multimeter if you have one or simply identify them using the image below.

Every component and its value is labeled on the PCB. Simply make sure to put them in right places. Resistors are the smallest element here,  let’s start by soldering them to PCB.

Solder them and cut out the legs with cutters, do the same to rest of the components if needed.

Then we can solder the transistors and capacitors.

Each of the capacitors has different value but you can find the value on the side of it. It’s important to remember about the polarities when connecting electrolytic capacitors as well as transistors. Make sure to connect them the right way.

There are the 5 LED’s we need to solder to the PCB.

Now, the part that will help sense music – a microphone.

The positive pin is not labeled on the microphone but we can easily recognize it.

The negative pin of the microphone is connected to its case.

As you can see in the image below + is the left leg and – is the right leg of the microphone.

Put it in place, solder and cut out legs.

At the end just solder the connector we will use to connect power to the board.

Here is the bottom side of PCB.

To power this project, I used my lab bench power supply that I set to 3V, that’s the voltage that should be supplied to the board to make it work.

Here is how the whole works.

There are a lot of tools that are useful in an electronics workshop, some are basic ones such as power supplies and multimeters but at some point, you will need more advanced tools like an oscilloscope or a function generator.

Those are quite expensive but fortunately. That is why today, we are going to build a cheap DIY square wave generator that in some case can replace an oscilloscope.

This is a very simple project making it perfect for beginners.

Square wave generator

These are the parts included in the kit.

Before we start with soldering, let’s remove the protective foil from the parts forming the case.

There is an instruction leaflet in the box that helps find important information. This is of help while identifying the components and their values.

As always, we start with placing the smallest components and soldering them to the board.

I will start with capacitors, make sure that all of the values are correct, each capacitor has its value different from the others.

After soldering all components, if their legs are too long cut them out.

After the capacitors, we can place the resistors in their appropriate position. On the leaflet, you can find where to put each resistor having as reference their value. Remember you can use your multimeter to find the resistance values of the resistors.

Solder them and cut out the legs.

Let’s solder the break out headers and the IC support.

To power it, we will use a standard DC jack, solder that together with a screw terminal that let us connect cables to generate our output signal.

The last 3 parts to solder are the potentiometers. One of them is different so make sure to put it in right place.

After soldering, we can plug the IC in.

The last part is to build the case.

As you can see it’s quite small so it wouldn’t take lots of space on your desk. You can power it with a voltage in the range of 9-12V.

EIA/MIL: 102

nF: Nanofarad

Every engineering student or high school STEM student probably knows what a capacitor. Therefore, defining it may not be necessary but here we go. A capacitor is a passive two-terminal electronic component that stores electrical energy in an electric field. It is used to add capacitance to a circuit which makes it an important part of every electronics project. It is also important to know that the physical form of capacitors vary which means there are different capacitor types currently in use.

Most capacitors are built to have two electrical conductors. The conductors are generally metal plates which are separated by a dielectric medium.  The conductor used could be a foil, thin metal film or an electrolyte. The dielectric medium separating the conductors are non-conductors themselves and can be made from glass, ceramics, air, mica, or plastic film. From these descriptions, it is obvious that capacitors come in different configurations and types. To help you make easy decisions when choosing a capacitor, this article will explore the common types of capacitors available to you.

The 7 Common Capacitors for Your Electronics Project

Ceramic Capacitors – The ceramic capacitor is a capacitor that makes use of a ceramic as a dielectric medium to separate the conductors in the capacitor. This means these capacitors are named after the dielectric medium used and their development.

The use of ceramics and ceramic capacitors provide multiple benefits to the user. These benefits include:

• A low loss factor which guarantees a reasonable level of stability when used.
• Its tight tolerances make it the commonly used option in RF circuits.
• Monolithic multi-layer ceramics can also be used as by-pass capacitors.
• It is relatively more affordable and it delivers high capacitance for your applications.

The common ceramic capacitor used are the COG – for low capacitance values, the X7R – for higher capacitance, and the Z5U is used for higher capacitance but delivers lower stability than COG or X7R.

Electrolytic Capacitors – The electrolytic capacitor takes its name from its build. In its case, an electrolyte-soaked sheet is generally placed between two aluminum conductor films. The electrolytic capacitor is the most common leaded type used. When used, it is recommended that the rated working voltage should not be exceeded. This is because electrolytic capacitors are prone to damage.

The applications and benefits of using an electrolytic capacitor include:

• It is a polarized capacitor commonly used in smoothening or filtering power supply rails.
• Its low stability level means it should be used in non-critical applications such as in timing elements.
• They do not function well in high-frequency environments. Electrolytic capacitors should be used for frequencies lower than 100KHZ

Tantalum Capacitors – Tantalum capacitors are popular used in applications where the physical size of a capacitor is a consideration. This is because they are much smaller than the traditional aluminum capacitors used in different devices. The capacitors build integrates a film of oxide and tantalum. These serve as the conductor and dielectric medium. Tantalum generally do not have high working voltages and coupled with their sizes, these features make them popular with electronics creators.

The applications and benefits of Tantalum include:

• They are polarized capacitors and may combust under excessive stress.
• They have a lower series equivalent resistance compared to other options.
• The generally have a lower voltage and 35 volts is usually the maximum of any Tantalum capacitor.

Polyester Capacitors – If the name ‘polyester’ does not ring a bell, do not fret. Polyester capacitors are also called different names such as a Mylar or PET capacitor. The naming options is due to the material used with these capacitors.

Mylar is the materials used as a dielectric medium and this material is sometimes called polyester or Polyethylene terephthalate (PET). The properties, applications, and benefits of polyester capacitors include:

• Polyester offers enhanced dielectric strength which makes it possible to develop small capacitors with high voltage.
• They are generally green in color and are affordable. The general color of this capacitor has also earned it the name ‘green caps’.
• A low tolerance of less than 10% means these capacitors can be used in diverse applications.

Polycarbonate Capacitors – Once again, the dielectric medium used lends its name to a capacitor. The polycarbonate capacitor consists of a polycarbonate dielectric that delivers stability and high tolerance. Although Polycarbonate capacitors are common, it is usually used as a second option to other capacitor types. The polycarbonate dielectric medium is constructed in a foil format with metallic electrodes serving as the conductors.

The properties, applications, and benefits of a polycarbonate capacitor includes:

• A high insulation resistance and a low dissipation factor.
• It can operate optimally in temperatures as low as -55C and as high as 125C.
• Polycarbonate capacitors can be self-healing as it vaporizes defective electrodes which restores the capacitor to life.

Polystyrene Capacitor – Although polystyrene capacitors are not widely used as others on this list, they are quite common and have interesting properties. Firstly, the capacitors make use of polystyrene dielectric medium between its conductors. The characteristics of polystyrene capacitors are high insulation, low leakage, and excellent temperature stability.

They are also relatively affordable and their properties, applications, and benefits include:

• They are generally applied in audio devices or hardware.
• They exhibit low leakage and low dielectric absorption which means a longer life span when used.
• They are not as available for purchase like other options due to their limited use in electronics.

Polypropylene Capacitor – Propylene capacitors are generally available or built as leaded components. These capacitors make use of a polypropylene dielectric which means they can be used where high degree of tolerance is a consideration. Polypropylene capacitors are commonly used in loud speakers as it guarantees enhanced-performance.

The properties and benefits of polypropylene includes:

• They exhibit high stability which makes them best for applications where capacitance stability is an important consideration.
• They are only available as leaded components and cannot be surface-mounted.

Summary

The common capacitor types listed here are versatile options that can be used in most applications. But it is important to note that some capacitors function better in certain applications when compared to others. Thus, it is important to always consider the application you need a capacitor for before choosing any of these capacitor types listed here.

The rise of IoT, Industry 4.0 and the smart revolution has triggered a butterfly effect on the electronics/hardware industry. This trend has led to electronics manufacturers having to innovate or be eaten by the competition. It has also led to an influx of new blood interested in taking over the electronics space and PCBWay is one of them.

Although everyone upsells their PCBs as the best in the business, the pudding is still in the eating. This is why in order to confirm what PCBWay PCBs have to offer, we took upon the task of creating a simple home controller using a PCB. And before discussing the details of how PCBWay stands out, here is an outline of the project I undertook.

Designing the Simple Home Control System

Scope of Project: As stated earlier, the goal was to create an interconnected home system tasked with accomplishing simple exercises. The project consisted of 6 push buttons and 6 LED paired with the push buttons. The push buttons were designed with the aim of controlling common devices that can be found in a home. Their functions include; controlling window opening mechanisms, controlling a fan, or switching a light bulb on and off.

Executing the Project— the first step, as always, was determining the functionalities of the circuit. Here, we drafted the circuit for the home control system on a white board and enlisted the help of KiCAD to design the PCB. The final schematic designs were generated in Gerber files and we proceeded to send the designs to PCBWay.

PCBWay –This is where PCBWay comes into the picture. First and foremost, it is important to state that PCBWay sent the physical PCB to us in a timely fashion. And when the PCB arrived, we soldered the components on the board and tested the design without encountering any hurdles. We then programmed a microcontroller chip to the behavioural patterns assigned to each buttons. The testing process was seamless and the home control system worked perfectly.

Our Verdict—the response from PCBWay was timely and professional. We actually made a mistake by sending the incomplete Gerber files in and received feedback about this immediately. On providing the complete files, we received the final PCB within 2 weeks.

Reasons Why We Recommend PCBWay

With the scope of the simple project executed out of the way, now is the time to examine the pros of using PCBWay. Here, we have outlined the six most important reasons why PCBWay stands out from its competitors.

High Quality Raw Materials

As we all know, the quality of raw materials used in developing a board plays a huge role in its effectiveness as a conduit. From our little project, it was easy to detect that PCBWay makes use of quality raw materials in developing PCBs. Their ability to do this is due to the use of PTH technology on their boards. PCBWay’s use of quality raw material on a regular basis is also made possible by integrate quality control checks.

PCBWay’s boards are routinely inspected by the relevant professional bodies to ensure the highest quality is adhered to. Some of the parameters quality control professionals inspect are: the copper thickness, signal reaction, and anomaly detection ability of components. In conclusion, the PCBWay board we used for the test project passed our checks with flying colours. The board was responsive and better produced than the majority of PCBs we have previously used.

Ability to Track the Progression of Your PCB Production in Real-Time

As stated earlier, our experiences with PCBWay’s customer unit was great. One important reason why this was so, is the real-time tracking service PCBWay has to offer. What does real-time tracking mean, you may ask? The real-time tracking feature allows you to track two aspects of your PCB design phase. These aspects are the status of the project been developed, and even the progression of your shipment! This is a service other PCB manufacturers do not offer!

Using the PCBWay backend, we were able to easily track the production stages for our PCB and knew when to expect it to be completed. We were also provided with a shipment express number. This allowed us track our PCB shipment and expect its delivery when it came.

A Vibrant PCBWay Online Community

when designing new PCBs, everyone knows that collaboration has a role to play. By collaboration, we mean some inputs, assistance, or correction from more-experienced heads. The PCBWay community provides you abundance assistance when needed. You can easily share your PCB designs in the PCBWay community and receive feedback from other electronics enthusiast.

As an aside, the PCBWay community provides you with an avenue to earn real cash. On posting your PCB design to the PCBWay Community; your designs could be purchased by interested third-parties. 10% of every purchase or order attached to your PCB design is given back to you! Lastly, PCBWay regularly conducts hackathons were great PCB designs are showcased to the public. After voting has been concluded, the winner is awarded a cash price to encourage him or her to do more.

The Most-affordable Prototyping Cost Available to You

The reason why you outsource your PCB prototyping projects is probably due to quality control. PCBWay gives electronics enthusiast another reason to outsource prototyping. And this reason is low prototyping cost. A PCBWay prototyping task costs approximately $5 or $10 depending on the scope of work. This is currently the cheapest prototyping cost in today’s PCB market.

Students, new registrants, and anyone strapped for cash can also take advantage of the PCBWay special coupon offer. Using the special coupon could mean that you end up paying not a single dime to get your prototyping done.

PCBWay Sponsorship for Non-profit Project

PCBWay continues to play an important role in helping students get their electronic projects off the ground. An example of this was their support of the Makerfaire SHA 2017 event. The dedicated sponsorship programme is open to students, beginners and NGO’s looking to develop something creative in the field of robotics and IoT devices.

Great After-Sale Services

With PCBWay, your complaints, changes, and needs are truly catered to. As explained earlier, our Gerber folder was missing a few files. PCBWay contacted us and after providing the files, we received feedback concerning our project within a day.

Now, the PCBWay after-sales team takes responsiveness to greater heights. And every complaint you have to make is answered within 24 hours. You can also take advantage of the PCBWay background system to lay your complaints on any issues you have. You will receive a response in 24 hours and according to international standards, a response ticket will be created for you immediately.

Our Conclusion

Working with PCBWay was an experience we intend to continue enjoying. This is because of the low prototyping prices on offer and the quick-response times we experienced. Therefore, PCBWay gets more than a pass mark from us, as we also endorse them as our PCB prototyping service of choice. You can also take advantage of the many benefits they offer by scheduling a PCB prototyping project with them today.

Everyone investing time in developing electronics or IoT hardware needs a PCB. Whether you are a sophomore, an enthusiastic DIYer or a professional innovator, the PCB still remains an important aspect of your electronics project. Therefore, it is only right to state that designing a PCB is the most crucial task you will be involved with during your creative task.

Now, to design the layout of your PCB in this digital age, you will require a PCB design software app. And in terms of choice, there are multiple options out there. This is why this post will focus on helping students looking to kick start projects, DIYers, and pros looking for other options find the best PCB design software. But before delving into the different available options, the factors you need to consider include the following:

• What is my budget?
• Do I intend to work on professional projects?
• Which operating system do I use?
• Do I intend to share designs in maker spaces?
• How difficult is a software’s learning curve
• What works best for single, double or multi-layered PCBs?

Your answer to these questions should determine the PCB design software you end up choosing. Therefore, the best options in each budget category and feature wise will be listed here.

The Top Free PCB Design Software for Students

Starting with test free PCB design software which are great for students and DIY enthusiasts looking to spend nothing, here are your best options:

Easy EDA

When in search of a versatile free web-based electronic design automation software app, you can’t go wrong with EasyEDA. As a web-based tool, all you need is to visit the EasyEDA website through your browser to get started. As a web-based tool, EasyEDA is compatible with every operating system. Therefore, you can start designing a PCB on your Linux, Windows or Mac-based OS immediately.

Taking a look at its features, its user-friendly interface means designing PCBs is a relatively easy task. Also, the vibrant EasyEDA online community means you can take advantage of the hundreds of tutorials available on its forums. On the flip side, you can chat with more experienced designers or even borrow a free PCB design to use for your project. EasyEDA is also friendly to a collaborative effort. This is due to the fact that you can import libraries and schematic drawings from other applications such as EAGLE or Altium. You can do this without facing any compatible issues.

The tools EasyEDA provides for your design task, includes the EasyEDA library, a design manager, drawing and wiring toolbars, and the choice of purchasing components from third parties.

Circuit Maker

Another great free electronic design automation (EDA) tool to look out for or consider is the Circuit Maker. Circuit Maker was designed with the sole aim of giving PCB designers a free EDA application with professional features to work with. This fact is reinforced once you know that the Circuit Maker was developed by industry heavyweights, Altium. As a web-based application, this EDA tool is compatible with most operating systems and is equipped with both design and collaborating features you would find helpful.

Some of the features to look out for include; extensive push and shove routing capabilities, the choice of editing multi-sheet schematics, one-click manufacturing, etc. The ability to also easily collaborate with other makers on Altium’s extensive community is one that appeals too many designers. The Circuit maker is totally free and compatible with other established PCB EDAs such as EAGLE, OrCAD, pCAD, etc. This makes importing designs from these applications into Circuit Maker possible. As great as the CircuitMaker is, note that it does not have all the premium features that come with the paid Altium EDA.

KiCAD

If this was a popularity contest, KiCAD easily wins this as it is the most popular EDA application in the free category. First and foremost, it is important to state that KiCAD is a suite of offline applications. Therefore knowing its compatibility status with different operating systems is important. Thankfully, KiCAD is a cross-platform application and can be installed/used on the Windows, Linux, and Mac operating systems. And unlike the Circuit Maker, the KiCAD application is totally free and you do not have to pay to unlock any premium features.

With KiCAD, you have a versatile schematic editor with a friendly user interface. This makes it possible to quickly learn how to design with this app and start creating with ease. KiCAD is also quite extensive in its application and you can create a 32-layered PCB using this free resource. You can also take advantage of its 3D viewer for interactive designing and its vibrant community for tips. All these features make design and collaborating or sharing your ideas easy to accomplish. KiCAD also has its dedicated library and can integrate libraries from other EDA tools which are also great for collaboration.

DesignSpark PCB

If you are into schematic designs for IoT projects and other smart devices, this EDA tool might just be the best thing you will ever come across. The DesignSpark PCB is great for mechanical and electronic designs. In terms of compatibility with operating systems, DesignSpark PCB is native to the different Windows operating systems. But with emulation software applications, you can get this EDA application to run on your Mac or Linux-powered computer. DesignSpark PCB has a truly extensive library with over a million parts and a vibrant community contributing to its library.

Note that DesignSpark PCB is a standalone suite that needs to be installed on your PC. Therefore, you have to be mindful of its installation requirements. Once that is out of the way, you have the following features to take advantage off; limitless schematic sheets to work with, create a bill of materials however you choose, etc. Other features that make the DesignSpark PCB designer a great tool is the option of creating your own libraries for your peculiar projects. DesignSpark is also user-friendly and you can seamlessly integrate external projects into your existing workflows.

Fritzing

If you are big on trying new software applications, then the Fritzing EDA is a tool you should consider. This product of a collective German maker community is a simplistic PCB design software with extensive features which you can use for your electronics projects. Fritzing is compatible with Windows, Linux and, Mac operating systems. As an open-source EDA, the Fritzing is totally free and all you need to get started is its suite files. Some of the features to look out for are the Fritzing fab and its compatibility abilities. The Fritzing Fab allows you to turn your circuits into a customized PCB with ease. Although the creation process is cheap, it is by no means free.

You can also import libraries and designs done on other PCB design applications into the Fritzing user-interface. The software makes use of a simplistic approach to design which may just produce the creative spark you are looking for.

The Top Paid PCB Design Software Applications for You

Now, industrial electronics manufacturers may require a PCB design software with advanced features for their work. If you fall into this category, a paid EDA tool may just be the solution you need. So, here are the top PCB design tools you should use for your schematic design applications.

Altium Designer

Altium has become a household name in the electronics and hardware design industry due to its extensive professional use. With Altium, you can work on diverse variables of any project without having to create new projects to accommodate your ideas. Other features you would use extensively are its real-time design process which integrates the price, features, and availability of parts into a project. Altium also promises a speedy design process due to certain features it offers. One of such feature is its routing engine which allows you to manipulate different components quickly. Its Native 3D design is also quite helpful with design and troubleshooting schematics.

It is important to state that Altium is only available on the Windows operating system. But this limitation does not extend to its compatibility with other EDA tools. You can choose to import your projects into Altium’s workspace and make use of its pro features. As stated earlier, Altium is a paid software suite but you can choose to reduce its cost by taking advantage of its partner packages.

EAGLE

Autodesk’s sojourn into the EDA or PCB design software space started with its introduction of 123D Circuits. But its successful purchase of EAGLE saw that effort integrated into the more versatile and powerful EAGLE suite. That being said, EAGLE definitely delivers as a professional PCB design application. It provides you with a powerful schematic editor, intuitive PCB layout tools, 3D design, and a vibrant online community to take advantage off. Eagle is compatible with the popular Windows, Linux, and Mac operating systems. Therefore, it can be easily integrated in offices that make use of PCs with varying operating systems.

Like with most Autodesk offerings, the entire EAGLE package must be paid for before use. And everyone gets a free monthly trial to decide if the EAGLE is for them. Students are also allowed to use a limited version of EAGLE without paying for it.

OrCAD

Another popular PCB design software you should consider for professional use is OrCAD. This design software built in Oregon for PCB design purposes and for simulation. This is why the complete OrCAD suite includes; the OrCAD Capture and PSpice. OrCAD capture is the suite needed for your schematic PCB designs. It integrates user-friendly tools and professional-grade features that will intuitively assist your design projects.

The PSpice suite is a simulation and verification tool used in verifying the applicability of circuits. Electronic manufacturers use the PSpice suite for reliability, cost, and yield analysis. OrCAD is capable of simulating circuit designs from other software applications such as MATLAB and Simulink. This makes it quite unique when compared to other PCB design software applications in its category. OrCAD is definitely not a free software package. You can choose to manage how much you spend by selecting the cheaper packages OrCAD offers its professional users. Finally, OrCAD also boasts of a vibrant community which can provide you with the support you may need when working on a project.

Multisim

This is an advanced, industrial-grade PCB design software package that can be used by students, pros, and researchers. The Multisim package also consists of a PCB schematic design tool and a simulation package for circuit analysis. The greatest selling point of Multisim is its vibrant learning environment that supports everyone. The tool provides an extensive library and an easy schematic-to-prototyping process for industrial use.

Multisim is also great for researching and analyzing design tasks with a view to reducing errors and enhancing the performance of your design. Although this PCB design software is a paid option, its student’s suite is free and allows you to take advantage of its versatile features at need.

Allegro PCB Designer

Allegro offers a diverse range of suites with different features matching your current design need. This means if you require a tool for speedy design projects, you can use its high-speed option, and if you intend to collaborate, its team design option is also available. In terms of ease of use, the Allegro user-interface is quite friendly and provides you with the PCB design tools you will need for your projects.

As with most professional PCB design software applications, Allegro isn’t free. But it comes with a versatile payment plan that allows you to pay for only the design features you require. Allegro is compatible with Windows, Linux, and Mac operating systems.

Conclusion

There are a variety of PCB design software applications you can choose to use for your electronics projects. These tools have varying capacities and features therefore; your design requirements should determine your choice. That being said, when finally taking the schematics-to-prototyping step, PCBWay can help develop your schematics into high-performing board regardless of how complex your schematics are.

One of the major driving forces behind how electronics and other hardware function is the printed circuit board (PCB). This fact is something everyone interested in electronics knows. But for software designers and other non-technical people, a PCB is basically a connector or bridge that supports electrical connections within a device. Therefore, before taking advantage of the benefits they offer, you must first understand PCBs.

In tech-speak, a printed circuit board is a board that mechanically support and electronically connects electronic components in devices. It accomplishes this task through the use of conductive tracks, pads, and other features. These features are usually etched on sheet layers of copper and laminated onto layers of a nonconductive substrate. The components of a PCB are generally or always fastened to the board by soldering.

Using simpler language, the PCB is a board made from plastic which has been reinforced with glass. And attached to the board are copper lines and pads that allow an electrical charge to pass through the PCB to the components of a device. If you have ever opened a calculator or game controller out of curiosity as a kid, you have seen a PCB.

Properties and Characteristics of a PCB

A PCB has distinct characters and components that must be understood before designing or using one. Starting with the conductive tracks, which are also known as circuit traces, the tracks serve as wires. But in this case, they are firmly kept in place and are separated or insulated by air and the substrate material of the board. The conductive tracks have been highlighted in the image below.

1. Conductive tracks
2. through-holes
3. Components

A PCB is also designed with pads and this serves as connectors, while vias pass the connection between the board’s layers of copper and other solid conductive features on the board. Depending on what a board is built to achieve, other conductors, and components are usually mounted on the board. A PCB can be designed to have multiple copper layers according to how they will be applied. For example, a two-layer has copper layers on both sides of the board. A multi-layered board integrates even more copper layers between the layers of its insulating material.

The components on a PCB are mounted on it through two popular methods. The first is method involves through-holes. Here, components with wire leads are passed through the board and are soldered to traces on the other end. This mechanically keeps the component in place and connects it electronically through the traces. The second mounting technique is the surface-mount. Here, the component lead is soldered to traces on the same surface as the component.

Both mounting methods are generally used interchangeably on a circuit board. The old rule of thumb, which is still efficient, is heavier components like capacitors should be secured using a through-hole and lighter components using a surface-hole. Lastly, the pattern to be etched on the copper layers is called artworks. Artworks are designed using photoresist and are etched firmly by light exposure. Now you know the basics and different components of the board, understanding the design process is the next phase.

The Techniques for Designing a PCB Board

There are a couple of ways to go about designing a PCB board. The three commonly used methods are:

1. Iron on glossy paper
2. Circuit by hand on PCB
3. Laser cutting edge etching method.

With these three methods, the basic design process still remains the same. The design process is started by drafting the schematics for your board using CAD software or PCB layout software. Currently, you can find many open-source applications such as PCB Wizard to help you with this task. The next step is cutting the copper board and transferring the PCB print onto the copper layer. To make this process more relatable below is a highlight or outline of the steps:

• Design Schematics – With the aid of CAD software, you can easily design your own schematics or borrow one from the public library of the app you chose.
• Take a Printout of Your Circuit Board Layout – The print out should be taken using an A4 photo paper. When doing this, ensure you select a black output so the print out is in black ink. Also, ensure the print is done on the glossy surface of the A4 paper.
• Cut-out Copper Board – The next step is getting your board. This board should fit the layout and can be cut using a cutter or hacksaw. The surface of the copper board should also be smoothed with an abrasive sponge. This will allow the designed schematics on the printout stick with ease.
• Transfer Printout Onto the Board – Finally, you can now transfer the schematics onto the board using any of the three techniques outlined in the beginning. How to accomplish this will also be discussed in the next section.

Designing Techniques: Iron on Glossy Paper

The Iron on glossy paper technique for etching printout onto the circuit board is generally applied for complex designs. The process starts by placing the copper plate you cut onto the A4 paper. Ensure the paper and plate is held in place with tape. When doing the placement, it is important to ensure the correct alignment you require is achieved.

The second step to take is where your iron will be necessary. By iron, I mean an actual electric iron for clothing. Now, place the board and the taped A4 paper on a flat surface. The arranged plate must be placed in such a way that the back of the A4 paper faces you while its front is pressed onto the copper plate. Before applying the heated iron, some protective or safety measure must be put in place. This includes the wearing of gloves and having a handling device—plier or spatula—by your side.

Next, hold one end of the copper plate/A4 paper arrangement and apply the iron to the other end for approximately 10 seconds. Continue to switch ends and iron the entire surface for 10 minutes. You should also apply some pressure while ironing for maximum effect. At the end of this exercise, the heat from the iron should transfer the ink from the glossy A4 paper to the copper plate. But your job is not yet complete. You still have to remove the paper from the copper plate. To do this, place the copper plate arrangement into lukewarm water for 5 to 10 minutes. This would soften the paper and allows you to peel it from its anchor. Once this is done, you will have your printed copper plate.

Note that if some of the artwork is faint when ink is transferred to the copper plate. You can strengthen the ink outline by using a blue marker.

Designing Circuit Boards by Hand

The next method you can use to stamp your schematic design on the copper plate is drafting by hand. In this method, you can use a pencil to sketch the circuit on the copper plate. Then proceed to strengthen your sketch with a permanent marker. If you are not so good at sketches, you can also attempt tracing the circuit design onto the plate. Simply place the A4 sheet over the plate and use a lead pencil to trace.

Once this is accurately done, you will have your circuit schematic on the copper plate. This is the best method for simple or small circuit designs. As you must have noted, tracing simple schematics reduces the possibility of making any errors.

Designing Circuit Boards Using Lasers

The third method involves the use of lasers to etch schematic designs onto a copper plate. In this case, the laser sintering machine used is usually programmed to trace your schematic diagram on the copper plate. This is obviously a faster method of doing things and it is used in industrial factories. Therefore, the use of a laser is a commercial process and it is applied by most PCB businesses to mass-produce circuit boards.

Now that the three methods, for getting your schematic design on the copper plate have been discussed, the next step is etching the PCB board and the schematic drawing on it. Here, an etching fluid or solution is used. This solution is ferric chloride solution (FeCl3) which must be handled with care.

Etching the PCB

The etching process involves placing the copper plate into a solution of FeCl3. Therefore, the process is kick-started by having your equipment in place. Hand gloves for safe handling, a bucket or can for mixing the solution and pliers for handling the submerged copper plate.

Now, fill up the plastic bucket or can with water. Put in 2 -3 teaspoons of FeCl3 into the water and wait till it dissolves. The copper plate can now be dipped into the solution. It should be left submerged for 30 minutes. During this time, the FeCl3 solution will react with the unmasked copper and remove all the unwanted copper from the PCB. This removal of copper is what is actually termed etching.

Once the 30 minutes are up, the pliers should be used to remove the copper plate from the solution. You are expected to observe the etching pattern and if it isn’t complete, submerge the copper plate for more minutes inside the solution. You can now rinse the copper plate with care and leave it out to dry. It is important that the FeCl3 solution is properly disposed of. To do this, further, dilute it by adding a lot more water and throw it at a safe place. Note that, your sink/plumbing, streams, and rivers are not safe places because the solution can damage plumbing and poison aquatic animals.

Post-processing the Copper Plate

Once the etching process is complete, the next step is planning how to integrate components on the board. If you intend to use through-hole mounts, then you will require a PCB drilling tool. The PCB driller should be used to make neat holes on the board according to your schematics. If you are partial to colour and want your PCB green, apply solder-resistant green paint before the soldering process.

Once the through- holes have been made, you can now integrate your capacitors, transistors, LED lights, and inductors in place. Once this is done, you will have your own functional PCB in your hands. You can then proceed with your electronics project whenever you choose. Note that these basic principles also apply when designing an 8 or 16 layer PCB. All you have to do is be meticulous with your approach.

Summary

The process of designing a PCB is one that needs some practice. Therefore, with more practice comes better execution. But for many electronics enthusiasts, these processes are time-consuming and may be too technical. This is why it is advisable to simply purchase the PCB of your choice the moment you need one. It is also possible to request a PCB to be fabricated according to your own schematics. You can contact us today to learn more about how we can help.

Let’s revive our old friend the fidget spinner!. It won’t be a bad idea if we decide to add a few LEDs to a fidget spinner shape printed board.

Here is the list of all component we are going to use in this DIY project.

This kit comes with clear instructions on how to put the parts together.

First, we will solder both integrated circuits, there is a mark on the PCB and on the package of those IC. Make sure that those two line up together.

There is a place for three resistors next to both ICs. Let’s put it in place. Those should be labeled 201.

Between the IC and resistors, we will solder all of the LEDs. Make sure that the green labels on each LED match the vertical line next to LED pad on the PCB.

On the third arm of the PCB, we have to solder one resistor and a button.

Rotate the PCB and put the battery holders in place.

Turn the PCB upside down and solder all them. That’s the last thing to solder.

Now we can take off the protective foil from all of the acrylic parts.

And we can assemble the frame of our spinner. For that, we have to use the acrylic parts and few screws. The whole assembly process is well explained in the instruction manual.

And there you go!

That was a quick one, but that thing can sit on your office table making you proud of your accomplishment everytime you look at it.

These days everyone wants faster internet, but copper wires reached their limit so we are using something better than copper. That’s fiber! In this simple DIY project you will see how light travels through a fiber cable. There are just 4 connections to be soldered in this project making it friendly and perfect for beginners.

Here are the components included in this kit.

Let’s now start building.

We will start with soldering the 2 cables to the LED. Solder the red cable to the longer leg of the LED and the blue cable to the shorter one.

We have to solder the LED to the battery holder. Make sure to solder the red cable to the positive of the battery holder and the blue cable to the negative as I mentioned in the previous step.

And that’s the end of soldering for today.

Let’s construct the frame.

We have to connect those together with pieces of a double-sided tape to create the object in the image below.

Make sure that the hole is on the top. Put a pin in the hole.

Grab the orange tube and put the fiber cables in it from the top side and then insert the LED from the bottom. Push that tube on the pin, be careful to not damage the LED.

And here we go!