Open Source Arduino Learner Kit

This is a hardware development board designed for Arduino beginners. Lots of IO devices are in-built in the board.

Similar projects worth following
This kit is for the beginner who is going to learn Arduino having some hands-on experience. This Kit is also a good choice for the teachers who like to teach Arduino to their students in an easy way.

Following experiments can be performed using the Kit:

Digital Output:
Controlling LEDs
Generating Tone & Music

Digital Input:
Interfacing button switch
Interfacing DHT11 Sensor

Analog Input:
Reading Analog data from a potentiometer
Interfacing LM35 temperature sensor

Analog Output (using PWM):
Generating 16M colors using the RGB LED.

SPI Communication:
Interfacing 74HC595 Shift Register
Interfacing MAX7219CNG for driving DOT Matrix/seven-segment display

I2C Communication:
Reading date and time from DS1307 RTC

UART Communication:
Interfacing GROVE GPS and Bluetooth Module

Display Interfacing:
Driving 16 X 2 Character LCD display

You will be wondering to know that the Kit is designed to experiment with all the mentioned topics in previous section. So, it can be an Ideal Learner Kit for learning Arduino Programming.

[The Kit includes onboard 6 Green LED, 1 RGB LED, 1 Potentiometer, 1 LM35 Sensor, 1 DHT11 Sensor, 4 Button Switch, 4 Seven Segment Display, 1 8X8 Dot Matrix Display, 1 MAX7219CNG IC, 1 74HC595 Shift Register, 1 Buzzer, 1 16X2 LCD display, 1 DS1307 RTC, 3 Grove Universal Connector.]

Watch the demo video:

Every device used in this kit get power from USB cable used for programming. You can also provide power using the barrel jack. Three Grove connectors provide opportunity to connect unlimited Grove sensor to the board. Optionally, any Arduino compatible device can be connected using jumper wire as female pin header is soldered in the board.  

Adobe Portable Document Format - 40.77 kB - 08/09/2019 at 12:49


Adobe Portable Document Format - 36.45 kB - 08/09/2019 at 12:49


Grabber files for professional PCB manufacturing

Zip Archive - 166.46 kB - 08/08/2019 at 16:32



Schematic file designed in Eagle

sch - 1.06 MB - 08/08/2019 at 16:31



PCB Layout file designed in Eagle

brd - 305.89 kB - 08/08/2019 at 16:31


View all 6 files

  • 1 × Arduino Nano
  • 1 × 16 X 2 Character LCD
  • 1 × 74HC595 Shift Register IC
  • 1 × DS1307 RTC IC
  • 4 × BC547 General Purpose NPN Transistor

View all 28 components

  • Testing with 7 Segment Display Code​

    Md. Khairul Alam08/25/2019 at 03:41 4 comments

    A 4 digit seven segment display is included in the kit. Each segment in the display module is multiplexed, meaning it shares the same anode connection points. And each of the four digits in the module have their own common cathode connection point. This allows each digit to be turned on or off independently. Also, this multiplexing technique turns the massive amount of microcontroller pins necessary to control a display into just eleven or twelve (in place of thirty-two)!

    The LED segments of the display require current-limiting resistors when powered from a 5 V logic pin. The value of the resistor is typically between 220 and 470 ohms. And, driver transistors are recommended to provide additional driving current to the LED segments, because each pin of a microcontroller can source or sink near 40 mA of current only. When all (seven) segments of the display turned on at once (the numeral 8), the current demand will exceed this 40 mA limit. The image shown below indicates the basic wiring diagram of the current limiting resistors and driver transistors.

    All the above connections are made in the board. You just need to connect 4 digit pins and 7 segment pins to the Arduino digital pin followed by the Arduino sketch. Carefully follow the hookup diagram to complete your hardware, and then upload the sketch to Arduino using the Arduino IDE as usual. The finished circuit can display the temperature using on-board LM35 temperature sensor. Arduino analog pin A0 should be connected to the signal out of the sensor. 

    //the pins of 4-digit 7-segment display attach to pin2-13 respectively 
    int a = 2;
    int b = 3;
    int c = 4;
    int d = 5;
    int e = 6;
    int f = 7;
    int g = 8;
    int p = 13;
    int d4 = 12;
    int d3 = 11;
    int d2 = 10;
    int d1 = 9;
    void setup()
      //set all the pins of the LED display as output
      pinMode(d1, OUTPUT);
      pinMode(d2, OUTPUT);
      pinMode(d3, OUTPUT);
      pinMode(d4, OUTPUT);
      pinMode(a, OUTPUT);
      pinMode(b, OUTPUT);
      pinMode(c, OUTPUT);
      pinMode(d, OUTPUT);
      pinMode(e, OUTPUT);
      pinMode(f, OUTPUT);
      pinMode(g, OUTPUT);
      pinMode(p, OUTPUT);
    int del = 5;
    int temp;
    void loop()
      temp = analogRead(A0)*500/1023;
      clearLEDs();//clear the 7-segment display screen
      pickDigit(0);//Light up 7-segment display d1
      pickNumber((temp/1000));// get the value of thousand
      delay(del);//delay 5ms
      clearLEDs();//clear the 7-segment display screen
      pickDigit(1);//Light up 7-segment display d2
      delay(del);//delay 5ms
      clearLEDs();//clear the 7-segment display screen
      pickDigit(2);//Light up 7-segment display d3
      //pickNumber(n%100/10);//get the value of ten
      delay(del);//delay 5ms
      clearLEDs();//clear the 7-segment display screen
      pickDigit(3);//Light up 7-segment display d4
      //pickNumber(n%10);//Get the value of single digit
      delay(del);//delay 5ms
    void pickDigit(int x) //light up a 7-segment display
      //The 7-segment LED display is a common-cathode one. So also use digitalWrite to  set d1 as high and the LED will go out
      digitalWrite(d1, LOW);
      digitalWrite(d2, LOW);
      digitalWrite(d3, LOW);
      digitalWrite(d4, LOW);
        case 0: 
        digitalWrite(d1, HIGH);//Light d1 up 
        case 1: 
        digitalWrite(d2, HIGH); //Light d2 up 
        case 2: 
        digitalWrite(d3, HIGH); //Light d3 up 
        digitalWrite(d4, HIGH); //Light d4 up 
    //The function is to control the 7-segment LED display to display numbers. Here x is the number to be displayed. It is an integer from 0 to 9 
    void pickNumber(int x)
        case 1: 
        case 2: 
        case 3: 
        case 4: 
        case 5: 
        case 6: 
        case 7: 
        case 8: 
        case 9: 
    void clearLEDs() //clear the 7-segment display screen
      digitalWrite(a, LOW);
    Read more »

  • Testing with 8X8 Dot Matrix code

    Md. Khairul Alam08/23/2019 at 19:23 0 comments

    The kit includes a 8x8 LED matrix. The LED Matrix is connected using the MAX7219 driver.  The MAX7219 driver IC is capable of driving 64 individual LEDs while using only 3 wires for communication with the Arduino, and what’s more we can daisy chain multiple drivers and matrixes and still use the same 3 wires. 

    The 64 LEDs are driven by 16 output pins of the IC. The question now is how is that possible.  Well the maximum number of LEDs light up at the same time is actually eight. The LEDs are arranged as 8×8 set of rows and columns. So the MAX7219 activates each column for a very short period of time and at the same time it also drives each row. So by rapidly switching through the columns and rows the human eye will only notice a continuous light.

    Note how the pins of a common 8×8 LED Matrix are internally arranged, so if you are building a matrix on your own you should consider it. Also note that a common breakout board for the MAX7219 comes with a resistor between the 5V and the IC pin number 18. The resistor is used for setting the brightness or the current flow to the LEDs.

    The VCC and GND of the module go to the 5V and GND pins of the Arduino which are already made and the three other pins, DIN, CLK and CS go to any digital pin of the Arduino board. 

    #include "LedControl.h"
    #include "binary.h"
     DIN connects to pin 12
     CLK connects to pin 11
     CS connects to pin 10 
    LedControl lc=LedControl(12,11,10,1);
    // delay time between faces
    unsigned long delaytime=1000;
    // happy face
    byte hf[8]= {B00111100,B01000010,B10100101,B10000001,B10100101,B10011001,B01000010,B00111100};
    // neutral face
    byte nf[8]={B00111100, B01000010,B10100101,B10000001,B10111101,B10000001,B01000010,B00111100};
    // sad face
    byte sf[8]= {B00111100,B01000010,B10100101,B10000001,B10011001,B10100101,B01000010,B00111100};
    void setup() {
      // Set brightness to a medium value
      // Clear the display
    void drawFaces(){
      // Display sad face
      // Display neutral face
      // Display happy face
    void loop(){

  • Testing with LCD code

    Md. Khairul Alam08/23/2019 at 18:47 0 comments

    In this part, I’ll explain how to connect and program an LCD using the board. The display used in the kit is a 16×2 LCD display. You may be wondering why it’s called a 16×2 LCD. The part 16×2 means that the LCD has 2 lines, and can display 16 characters per line. Therefore, a 16×2 LCD screen can display up to 32 characters at once. It is possible to display more than 32 characters with scrolling though.

    The LCD’s integrated in the kit uses the standard Hitachi HD44780 driver.  These displays can be wired in either 4 bit mode or 8 bit mode. Wiring the LCD in 4 bit mode is usually preferred since it uses four less wires than 8 bit mode and the kit has only 4 bit mode option. In practice, there isn’t a noticeable difference in performance between the two modes.

    There is some basic and common connection for LCD which are already made in the kit. You only need to connect 6 pins of LCD to 6 digital pins of the Arduino. These pins are:

    • RS (Register Select)
    • E (Enable)
    • D4-D7 (Data Bus)

    Connect this 6 pins to 6 digital pins of Arduino and upload the following code by changing the pin configuration according to your connection:

      LiquidCrystal Library - display() and noDisplay()
     Demonstrates the use a 16x2 LCD display.  The LiquidCrystal
     library works with all LCD displays that are compatible with the
     Hitachi HD44780 driver. There are many of them out there, and you
     can usually tell them by the 16-pin interface.
     This sketch prints "Hello World!" to the LCD and uses the
     display() and noDisplay() functions to turn on and off
     the display.
     The circuit:
     * LCD RS pin to digital pin 12
     * LCD Enable pin to digital pin 11
     * LCD D4 pin to digital pin 5
     * LCD D5 pin to digital pin 4
     * LCD D6 pin to digital pin 3
     * LCD D7 pin to digital pin 2
     * LCD R/W pin to ground
     * 10K resistor:
     * ends to +5V and ground
     * wiper to LCD VO pin (pin 3)
     Library originally added 18 Apr 2008
     by David A. Mellis
     library modified 5 Jul 2009
     by Limor Fried (
     example added 9 Jul 2009
     by Tom Igoe
     modified 22 Nov 2010
     by Tom Igoe
     modified 7 Nov 2016
     by Arturo Guadalupi
     This example code is in the public domain.

    // include the library code:
    #include <LiquidCrystal.h>
    // initialize the library by associating any needed LCD interface pin
    // with the arduino pin number it is connected to
    const int rs = 12, en = 11, d4 = 5, d5 = 4, d6 = 3, d7 = 2;
    LiquidCrystal lcd(rs, en, d4, d5, d6, d7);
    void setup() {
      // set up the LCD's number of columns and rows:
      lcd.begin(16, 2);
      // Print a message to the LCD.
      lcd.print("hello, world!");
    void loop() {
      // Turn off the display:
      // Turn on the display:

    The output on the display:

View all 3 project logs

  • 1
    Collecting the Components

    The first step is to collect all the components mentioned in the component list. All the components are very common. So you can find the components in your local parts store. You can also buy the components from or

  • 2
    Designing the Schematic

    This is the most important step of making the kit. The complete circuit and board layout were designed using Eagle cad. I make the schematic part by part so that it can be easily understandable and you can modify it easily according to your requirement.

    The Eagle source file is attached in the file section. You can download the source from that section.

  • 3
    Designing PCB Layout

    If you want to make your design more appealing, then PCBs are the next step. With the help of PCBs, we can avoid common problems like noise, distortion, imperfect contact, etc. Moreover, if you want to go commercial with your design, you have to use a proper circuit board.

    But, many people, especially beginners, will find it difficult to design circuit boards as they feel it as a tedious job and requires extreme knowledge in circuit board design. Designing printed circuit boards is actually simple (yes, it does need some practice and efforts).

    Note that the Schematic's job is only to define the parts and the connections between them. Only in Board layout does it matter where the parts physically go. On Schematics, parts are laid out where they make sense electrically, on Boards, they are laid out where they physically make sense, thus a resistor that is right next to a part in the Schematic may end up as far away from that part as possible in the Board.

    Typically, when you lay out a board, you first place the parts that have set locations that they need to go, like connectors. Then, group up all parts that logically make sense together, and move these clusters so that they create the smallest amount of crossed unrouted lines. From that point, expand those clusters, moving all of the parts far enough apart that they don't break any design rules and have a minimum of unrouted traces crossing.

    One thing with printed circuit boards is that they have two sides. However, you typically pay per layer that you use, and if you are making this board at home, you might only be able to reliably make one-sided boards. Due to the logistics of soldering through-hole parts, this means that we want to use the bottom of the PCB.Use the Mirror command and click on the surface-mount parts to switch them to the bottom layer. You may need to use the Rotate or Move command to correct the orientation of the parts. Once you have all of the parts laid out, run the Ratsnest command. Ratsnest recalculates the shortest path for all of the unrouted wires (airwires), which should clear up the clutter on the screen by a fair amount.

    The Eagle source (.brd) file is attached in the file section. Download from that section. 

View all 4 instructions

Enjoy this project?



Similar Projects

Does this project spark your interest?

Become a member to follow this project and never miss any updates