Delta Robot Open Source Project


This video shows how the robot operates acting  as a  pick and place Machine.

In this tutorial we will be making a pick and place Machine as this is the most common use for a delta Robot in the industry besides 3d printing. This project took me a bit of time to perfect and was very challenging, it involves:

  • Mechanical design and feasibility check
  • Prototyping and making of the mechanical structure
  • Electrical wiring
  • Software and graphical user interface development
  • Implementing of computer vision for an automated robot (still need your help in this part)

The Mechanical Design :

Before I started making the final robot (third version)I designed it on fusion 360 and here’s the 3d Model, Plans and overview:

For the plans it would be more accurate to  get the dimensions from the 3D Model Downloadable Here from my fusion HUB.

you also can download all the needed plans in PDF :

 Mechanical Assembly:

these are the stl file for the End effector and the rod supports downloadable on my thingiverse  : Link

Start by 3d printing the rod connection and the end effector. After that use wood or steel for the base I recommend its CNC cut for the precision as well as you should for the arms I made them from alucobond the material used for store fronts it’s made from rubber sandwiched between two thin aluminum sheet 3mm thick.

Next we have to work on the L shaped steel to mount the steppers, cut to 100mm and holes drilled to mount the steppers(hint: you can make the holes wider to be able to tension the belt )

Then the threaded 6 mm Ø  rods ,for the forearms connection 400mm length should be cut then threaded or hot glued to the ball joint I used this jig to ensure they all have the same length it is crucial for the robot to be parallel.

Finally the 12 mm Ø rods should be cut to about 130mm in length to be used for the pivot point of the robot connecting the 50mm Ø pulley.

Now that all the parts are ready you can start assembling everything which is straightforward as shown in the pictures keep in mind you need some sort of support like the pink one I used to be able to hold everything, better than what I did in the part2 video =D.


from minute 5 i talk about the electronics

The main thing we need to do is set up GRBL by downloading/cloning it from its Github repository I used the 0.9 version but you can update to 1.1 (Link: Add the library to arduino libraries folder and upload it to your arduino.

Now that GRBL is on our arduino connect it, open the serial monitor and change the default values as shown in the picture to match your robot configuration:

I used 50mm and 25mm pulley => 50/25 =1/2 reduction and 1/16th step resolution so 1° angle is 18 steps/°

Now the robot is ready to receive gcode commands:

M3 & M4 ⇒ activate / deactivate Vacuum

X10  ⇒ move stepper X to 10°

X10Y20Z-30.6  ⇒ move stepper X to 10° & Y to 20° and Z to -30.6°

G4P2  ⇒ Wait for two seconds (delay)

At this point with any gcode sender you can make it repeat preconfigured tasks like picking & placing.

download demo gcode demo.txt that you can stream to the robot.

GUI and Image Processing:


To be able to follow me on this you need to watch my video explaining the GUI, going through bits of the code & the interface starting from minute 8:30 :

The GUI is made with Visual Studio 2017 free Community version, I tweaked the code from for the kinematics calculations to determine its position. The EmguCV library for image processing and simple math to move the end effector to the position of bottle caps to pick them and place them is predefined position.

You can download the windows application to test with the robot from my github repository or all of the source code and help me build up on it as it needs more work and debugging. Visit it and try to solve the problems with me or give new ideas recommend it to people that can help. I ask for your contribution on the code and to support me in any way you can.

Now I thank you for checking this awesome project and stay tuned for more.

Follow me on:

WebSite ►

Twitter ►

Facebook ►

Instagram ►


Deltabot Sorting Machine Preparation

Deltabot Sorting Machine

Introductory Research


  1. Background :

Late this year I bought a delta 3d printer. I was fascinated by the design and mechanism, how it moves so dynamically by actuating its three accelerates and decelerates quickly maintaining the accuracy of the printing head position.

It made me think to study it and why not make my own delta robot. The occasion came up in this year’s project, I proposed the idea to my team and they liked it.

So we intend to make a deltabot with a different purpose than 3d printing, a pick and place machine sorting items according to different characteristics (color, weight…..)

2. The Delta Mechanism :

A delta mechanism is composed of three parts:

  1. The BASE:

A triangular shaped platform which houses the actuators in our case we chose stepper motors for their accuracy and repeatability, because all the weight resides in the base the arms of the robot can be very light reducing there inertia so they can accelerate very fast in an accurate way.

  1. The End-Effector:

A smaller triangular shaped platform which translates in the XYZ axis but stays parallel to the base platform, it also houses a suction device or a smell actuated arm to pick and drop the sorted items.

  1. The Arms:

Three symmetrical arms that move independently, Composed of an arm that is actuated from the base, a parallelogram acting as the forearm which is the connected to the end effector all its joints are ball joints. The parallelogram locks the end effector platform parallel to the base which is the difference between a delta bot and a Stewart platform and the ball joints give the end-effector the 3 Degrees of freedom DOF to move in the XYZ planes.

  1. Actuation Type Choice:

There is two types of actuation for these three arms either linear or revolute, common 3D printers use linear actuation, and industrial deltabot used for pick & place use revolute actuation. I chose the revolute actuation because it’s easier to make with minimal mechanical items and also cheaper as linear rods or wheels on aluminum profiles tend to be more expensive to buy than to directly drive the arms from the actuator.

3. Motion Study:

Only by rotating first part of the arms we are able to change the position of the end effector platform as shown in the figure below,


Input 3 rotations è output 3 translations on the X Y and Z axis.


Inverse kinematics was applied to determine the output angle of each servo for a desired position of the effector (xg,yg,zg). Each leg was solved individually. Cylindrical polar coordinates are used to take advantage of the circular symmetry. Each leg is projected into a 2D plane then basic geometry was used to determine the final servo output angle.

4. Design and Parts List

1. Mechanical Parts:
We will be needing a strong frame to support the weight of the motors and the base it needs to rigid and heavy to eliminate all the vibration when the arms are moving quickly so we can either use steel or aluminum profiles to make it.

For the Base and the end effector an acrylic (plastic) or a wooden board can be used

For the upper arm 3d printing the part can be easier as it’ll have many mounting points one side for the motor and the other side to connect the ball joint, if we don’t have access to a 3d printer we will be using acrylic.

For the parallelogram we need small rods need to be very light and 4 ball joints each.

The ball joint problem:
It may be difficult to find small ball joints (embout a rotule) on the market so we are not lucky we can make our own in a very clever way by combining two perpendicular pivot axes on the X and Y using 4 ball bearings.

The end effector will be equipped with an actuator to hold the items were picking preferably it’s a suction module but we can use a servo actuated gripper.

2. Electronics Components:

• As actuators we can use either servo motors or steppers I prefer steppers as they are more accurate in both position and acceleration, we need three in total
• If we are using steppers drivers are needed (DRV8825 or A4988)
• A microcontroller (an arduino Uno or Mega)
• Wires
• A color sensor
• Weight sensor

Essential parts List Proposal:

3 Stepper Motors NEMA17   Arm Actuator
3 A4988 3 Stepper Motor Driver
1 Arduino UNO Microcontroller board
12 Ball Joints  Mechanical joint linkage
1 TCS34725 Color sensor 1 Color sensor

I modeled the design on Fusion 360 and exported these renderings :

TunMaker at SOMEF

First of all i need to thank SOMEF for this opportunity and special thanks to my Supervisor Med Amine Chibani,Also all the members of the development & test team


As a student engineer in Electro-Mechanics I had the opportunity for an internship at SOMEF which is the leader company in its field of business here in Tunisia, with products that varies from simple home switches to home automation and smart house implementation it presented for me a company that I need to visit and a chance to widen my professional experience.
So I applied and they accepted me in the department of development and testing, not going to go in all the details I just want to tell you about my project so here we go.

The Internship

Main task: Design and manufacture of an instantaneous current measurement module, able to visualize the values on the computer in real time

With my supervisor we detailed what the project was and its functionalities :

The module needs to be able to measure the current up to 5 A we chose the IC ACS712 for that,an LCD-1602 to display the values everything will be controlled by an ARDUINO-UNO, using its serial port we will relay the values and print them in real time on an excel-sheet.

My first challenge was to read the Data Sheet of the ACS712 to interpret the output signal according to the passing current, after finding the formula I had to write and test the program on the arduino and display it on LCD.
The Second Challenge was to find a reliable solution to visualize and save these values on Microsoft-Excel in order to draw the curve. For that I found PLX-DAQ which is a software add-in of the Parallax Data Acquisition Tool (PLX-DAQ) for Microsoft Excel Acquires up to 26 channels of data from a microcontroller and places them in the columns as soon as they arrive. PLX-DAQ provides easy analysis of spreadsheets of collected data.

After testing the features separately from reading ,  displaying on an LCD and the real-time acquisition of the values. All that remains was writing the program.

For the circuits he asked me to make a shield housing the LCD screen for the arduino and input for the measuring circuit. The second circuit had one power input and three USB outputs with the ACS712 in the middle of it to measure the passing current.
To make the circuits I used Autodesk EAGLE here’s some pictures:

And I used my CNC to make the PCB’s and I had an acceptable result.


Now that circuits are made I needed a box for them so I made one using Autodesk fusion 360 for modelling and 3D printed them on my KOSSEL DELTA

And here’s the project Done :

DIY Mini Arduino Plotter

 Mini Arduino Plotter


We Made this plotter as a school project and since i learned a lot from my previous one this one came out perfect.

this plotter uses the same circuit as the previous one which you can read about and watch a complete tutorial in this post :

Second the pen holder mechanism is inspired from this video :


the firmware changed  as i used a servo motor this time is from this GitHub repository:

if you want to learn how to make your own gcode i made a tutorial for it :


and if your lazy like me to make your own gcode here’s a link to find some good cartoon pictures .gcode for your plotter :

Arduino IR remote

Simple Arduino Project : IR Remote


Making an arduino based IR remote is fairly simple thanks to the IR enables us to :

  1. Detect and Read IR Signal
  2. Decode It
  3. Send Ir Signal

which is all we need for an infrared remote as we will be sending a coded message to be able to identify each button.

this project has many applications other than duplicating a TV or radio IR remote but can be used to activate or trigger anything with an IR receiver up to 10 meters away.

Principle :

the IR light that an IR led cant be seeing with a human eye ( you can use a camera to see it) but IR receivers can.the arduino using the PWM function will blink the led at a certain frequency which is picked up by the TSOP Ir receiver which can interpret those bursts of IR light into data.


IR Library Download Link :

the first code i used is the IRrecdemo and IRrecvDumpv2 included in the arduino IR can read the IR signal of remotes and decode it .

IR Emitter code :

#include <IRremote.h>

IRsend irsend;

const int switch1 = 4;
 const int switch2 = 5;
 const int switch3 = 6;
 void setup() {
 pinMode(switch1, INPUT_PULLUP);
 pinMode(switch2, INPUT_PULLUP);
 pinMode(switch3, INPUT_PULLUP);


void loop() {

if (digitalRead(switch1) == LOW){
 irsend.sendNEC(0xE0E020DF, 32);}

if (digitalRead(switch2) == LOW){
 irsend.sendNEC(0xE0E0A05F, 32);}

if (digitalRead(switch3) == LOW){
 irsend.sendNEC(0xE0E0609F, 32);}



IR Receiver code :

#include <IRremote.h> // IR library
 const int RECV_PIN = 11; // TSOP IR Receiver Data PIN

const int switch1 = 2; //Switch or led's to be activated OUTPUTS
 const int switch2 = 3;
 const int switch3 = 4;

IRrecv irrecv(RECV_PIN);
 decode_results results;

void setup() {

 pinMode(switch1, OUTPUT);
 pinMode(switch2, OUTPUT);
 pinMode(switch3, OUTPUT);

void loop() {
 if (irrecv.decode(&results)) { // Receiving IR Signal and decoding it


if (results.value == 0xE0E020DF) {
 digitalWrite(switch1, HIGH);
 digitalWrite(switch1, LOW);
 results.value = 0x00000000;

if (results.value == 0xE0E0A05F) {
 digitalWrite(switch2, HIGH);
 digitalWrite(switch2, LOW);
 results.value = 0x00000000;
 if (results.value == 0xE0E0609F) {
 digitalWrite(switch3, HIGH);
 digitalWrite(switch3, LOW);
 results.value = 0x00000000;



DIY Power Supply


Salvaging parts from computers can be very useful especially the ATX power supply as it can be converted to a lab bench power supply giving us +3.3V  +5V   +12V -12V -5V outputs with lots of power ,mine a 300W unit gives up to 30A on the 5V output which can be very handy when powering big DC motors and other stuff so let’s gather the parts and start making our power supply , forgetting about batteries and cellphone chargers to power our circuits :

The video explains it all about the making watch it :

About The Circuit

What we need?

  • 5x Binding posts (red)
  • 1x Binding post (black)
  • 1x Toggle Switch
  • 1x 3mm Green LED
  •  1x 3mm Red LED
  • 2x 220Ω Resistor for the led’s
  • Dummy Load

Hers an image explaining the color code of the wires of a power supply :


We have to put a dummy load on the supply to keep it stable even when we only draw small amounts of current. Old power supply’s use the most amount of power on the 5v rail so we am going to be connecting the dummy load on the 5v if you have a newer power supply you’ll need to put them on the 12v rail

Assuming the dummy load should draw at least 0.5A.

  1. Here is the calculation if you have most of your power on 5V/3,3V rail:



2. Here is the calculation if you have most of your power on 12V rail:



Conclusion :

  • 5v     10Ω  2.5W
  • 12V   24  6W

The Connections image assuming you have an old Power Supply :


If you have most of your power on the 12V rail then you need to connect a 24Ω resistor to 12V instead of 10Ω to 5V.

My Power Supply Finished

Arduino Plotter the easiest way

Making a Mini Arduino Plotter


In this project I will show you how to turn two old DVD-drives into a mini plotter. This project is simple and easy also presents a good cheap practice if one day you want to make your own CNC machine as this plotter works with the same principle just way more lower the cost and using as much scrap parts as we can we will use the CD tray mechanism instead of a servo motor for the z axismini arduino plotter

What you will need?

2 DVD-drives

3 L293 H-bridges IC

1 Arduino UNO

1 Breadboard and some wires

Hot glue or anything that sticks

Scrap pieces of plastic

USB cable (to power the circuit from the PC)

Screw driver

Needed Software Links :


Getting What We need From The Drives

We will begin by disassembling the DVD-drives to get the stepper motors and the moving carriages grab a screwdriver open the metal case. The electronics inside we won’t be using them. I used the metal casing as the main body the front part of the CD tray is our Z axis SO Don’t BRAKE IT watch Part 1 for detailed instructions.


Preparing The Stepper Motors

After salvaging the parts we need it’s time to prepare the you can see in the video below they are connected with a yellow ribbon cable we cannot use that so we will need to wire new ones to be able to connect them THIS Part is TRICKY do it Carefully and don’t remove the ribbon cable solder the new ones on top of it or you’ll end up braking the motor so be careful not to damage it. Each one of the steppers needs 4 wires, Prepare and cut them to the same length put a tip of solder on top then solder them to the stepper motor.

The Electrical Circuit

As our Steppers are ready we will jump to wiring the circuit but first lets assemble the plotter. I mentioned earlier that we will be using the metal casings as our main body I used screws to attach them perpendicularly to each other then hot glued the two carriages one as X axis and one as Y axis.

Now the Z axis is glued with a piece of plastic to its back to the carriage of the Y axis and like that our plotter is 70% done.

Now Let’s Continue our Wiring use these diagrams to wire the steppers with h-bridges and the Arduino but keep in mind THAT YOU NEED TO IDENTIFY THE STEPPER SEPARATE COILS FIRST OR THEY WONT MOVE like in the video with a multi-meter set on the connection test as each coil goes to a side of the IC  L293D. The z axis has a built in DC motor which connects on a side of the third and last IC.

Connection to the Arduino:

X axis 2, 3, 4, 5

Y axis 6, 7, 8, 9

Z axis 10 11

And of course you can change this in the .ino code if you want

Initial Testing

Before trying our plotter let’s do some testing first to identify problems if there is any hopefully not.

To test  the  Z axis use this code upload it to arduino and it will make the pen go up and then go down:

#define I1 10 // Control pin 1 for motor
#define I2 11//  Control pin 2 for motor
void setup() {
Serial.begin( 9600 );
pinMode(I1, OUTPUT);
pinMode(I2, OUTPUT);
void loop() {
digitalWrite(I1 , LOW);
digitalWrite(I2 , HIGH);
digitalWrite(I2 , LOW);
digitalWrite(I1 , LOW);
Serial.println("Pen up!");
digitalWrite(I2 , LOW);
digitalWrite(I1 , HIGH);
digitalWrite(I2 , LOW);
digitalWrite(I1 , LOW);
Serial.println("Pen down.");


— For the X and Y axis it’s the same test code just change the numbers to 6 7 8 9

#include <Stepper.h>
const int stepsPerRevolution = 20;
Stepper myStepper(stepsPerRevolution, 2, 3, 4, 5);
void setup() {
// set the speed at 60 rpm:
// initialize the serial port:
void loop() {
// step one revolution  in one direction:
// step one revolution in the other direction:



Hopefully everything goes as expected and let’s move to making gcode and preparing the software to start plotting this video includes all the steps USE THE links to download the needed software and follow along. It IS Important to use Inkscape version 0.48.5 or the plugin that saves the files as gcode wont work.


-download and install processing:

-download and install inkscape version(0.48.5 important or the g-code plugin won’t work):

-download gcode plugin for inkscape (the installation note is included):

upload the sketch to arduino Tun_Maker_Mini_Arduino_Plotter.ino

now open gctrl.pde with processing change “COM38” with the usb port of your arduino and your good to go

Tunisian Maker: if you have a problem contact me on the forum or :

youtube :

facebook :

Simple LED POV Display

DIY Arduino POV

How to Make A DIY Arduino POV LED Display With 8 LED’s and an arduino using a drill to make it rotate



What is Persistence of Vision?

Persistence of vision is a kind of optical illusion whereby multiple discrete images blend into a single image in the human mind giving the impression of an animation like any .GIF animated image you see

we will use this trick to make a DIY Arduino LED POV


How does it work ?

we will be drawing letters in two dimensions using 8 led’s with the Y axis we have the led row and the X axis is moving so by blinking the led is a certain pattern letters and words will show.

to draw the letter B we will be flashing the led’s in 5 simultaneous raws making a matrix of 8×5 like the image on the right and the code in the arduino will be B[] = {1,1,1,1,1,1,1,1, 1,0,0,1,0,0,0,1, 1,0,0,1,0,0,0,1, 1,0,0,1,0,0,0,1, 0,1,1,0,1,1,1,0};

Making The DIY Arduino POV

Parts Needed :

  • one small piece of plastic to hold the LED’s
  • an arduino board
  • 8 LED’s and 240Ω resistors
  • a 9V Battery and Some wires
  • a Rotary thing to make it spin Like a Fan but i used my drill

Follow the instructions it video you will also need to upload the code to arduino and use the schematic below :

One thing more use the last loop in the code to print the letters or numbers you want and tweak Letter Space and Dot-time in the code for the best settings cause it is different for the rotation speed your chosen as fast you go as much you can write



The Arduino Code To Upload :

int NUMBER9[]={1,1,1,1,0,0,0,1, 1,0,0,1,0,0,0,1, 1,0,0,1,0,0,0,1, 1,0,0,1,0,0,0,1, 1,1,1,1,1,1,1,1};
 int NUMBER8[]={0,1,1,0,1,1,1,0, 1,0,0,1,0,0,0,1, 1,0,0,1,0,0,0,1, 1,0,0,1,0,0,0,1, 0,1,1,0,1,1,1,0};
 int NUMBER7[]={1,0,0,0,0,0,0,0, 1,0,0,0,1,0,0,0, 1,0,0,0,1,0,0,0, 1,0,0,1,1,1,1,1, 1,1,1,0,1,0,0,0};
 int NUMBER6[]={1,1,1,1,1,1,1,1, 1,0,0,0,1,0,0,1, 1,0,0,0,1,0,0,1, 1,0,0,0,1,0,0,1, 1,0,0,0,1,1,1,1};
 int NUMBER5[]={1,1,1,1,1,0,0,1, 1,0,0,0,1,0,0,1, 1,0,0,0,1,0,0,1, 1,0,0,0,1,0,0,1, 1,0,0,0,1,1,1,1};
 int NUMBER2[]= {1,0,0,0,0,0,1,1, 1,0,0,0,0,1,0,1, 1,0,0,0,1,0,0,1, 1,0,0,1,0,0,0,1, 0,1,1,0,0,0,0,1};
 int NUMBER1[]= {0,0,1,0,0,0,0,0, 0,1,0,0,0,0,0,0, 1,1,1,1,1,1,1,1, 0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0};
 int NUMBER0[]= {1,1,1,1,1,1,1,1, 1,0,0,0,0,0,0,1, 1,0,0,0,0,0,0,1, 1,0,0,0,0,0,0,1, 1,1,1,1,1,1,1,1};

 int _[] = {0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0};
 int A[] = {1,1,1,1,1,1,1,1, 1,0,0,1,0,0,0,0, 1,0,0,1,0,0,0,0, 1,0,0,1,0,0,0,0, 1,1,1,1,1,1,1,1};
 int B[] = {1,1,1,1,1,1,1,1, 1,0,0,1,0,0,0,1, 1,0,0,1,0,0,0,1, 1,0,0,1,0,0,0,1, 0,1,1,0,1,1,1,0};
 int C[] = {0,0,1,1,1,1,0,0, 0,1,0,0,0,0,1,0, 1,0,0,0,0,0,0,1, 1,0,0,0,0,0,0,1, 1,0,0,0,0,0,0,1};
 int D[] = {1,1,1,1,1,1,1,1, 1,0,0,0,0,0,0,1, 1,0,0,0,0,0,0,1, 0,1,0,0,0,0,1,0, 0,0,1,1,1,1,0,0};
 int E[] = {1,1,1,1,1,1,1,1, 1,0,0,1,0,0,0,1, 1,0,0,1,0,0,0,1, 1,0,0,1,0,0,0,1, 1,0,0,1,0,0,0,1};
 int F[] = {1,1,1,1,1,1,1,1, 1,0,0,1,0,0,0,0, 1,0,0,1,0,0,0,0, 1,0,0,1,0,0,0,0, 1,0,0,1,0,0,0,0};
 int G[] = {0,1,1,1,1,1,1,1, 1,0,0,0,0,0,0,1, 1,0,0,0,1,0,0,1, 1,0,0,0,1,0,0,1, 1,0,0,0,1,1,1,0};
 int H[] = {1,1,1,1,1,1,1,1, 0,0,0,0,1,0,0,0, 0,0,0,0,1,0,0,0, 0,0,0,0,1,0,0,0, 1,1,1,1,1,1,1,1};
 int I[] = {1,0,0,0,0,0,0,1, 1,0,0,0,0,0,0,1, 1,1,1,1,1,1,1,1, 1,0,0,0,0,0,0,1, 1,0,0,0,0,0,0,1};
 int J[] = {0,0,0,0,0,1,1,0, 0,0,0,0,1,0,0,1, 0,0,0,0,0,0,0,1, 0,0,0,0,0,0,0,1, 1,1,1,1,1,1,1,0};
 int K[] = {1,1,1,1,1,1,1,1, 0,0,0,1,1,0,0,0, 0,0,1,0,0,1,0,0, 0,1,0,0,0,0,1,0, 1,0,0,0,0,0,0,1};
 int L[] = {1,1,1,1,1,1,1,1, 0,0,0,0,0,0,0,1, 0,0,0,0,0,0,0,1, 0,0,0,0,0,0,0,1, 0,0,0,0,0,0,0,1};
 int M[] = {1,1,1,1,1,1,1,1, 0,1,0,0,0,0,0,0, 0,0,1,0,0,0,0,0, 0,1,0,0,0,0,0,0, 1,1,1,1,1,1,1,1};
 int N[] = {1,1,1,1,1,1,1,1, 0,0,1,0,0,0,0,0, 0,0,0,1,1,0,0,0, 0,0,0,0,0,1,0,0, 1,1,1,1,1,1,1,1};
 int O[] = {0,1,1,1,1,1,1,0, 1,0,0,0,0,0,0,1, 1,0,0,0,0,0,0,1, 1,0,0,0,0,0,0,1, 0,1,1,1,1,1,1,0};
 int P[] = {1,1,1,1,1,1,1,1, 1,0,0,1,0,0,0,0, 1,0,0,1,0,0,0,0, 1,0,0,1,0,0,0,0, 0,1,1,0,0,0,0,0};
 int Q[] = {0,1,1,1,1,1,1,0, 1,0,0,0,0,0,0,1, 1,0,0,0,0,1,0,1, 0,1,1,1,1,1,1,0, 0,0,0,0,0,0,0,1};
 int R[] = {1,1,1,1,1,1,1,1, 1,0,0,1,1,0,0,0, 1,0,0,1,0,1,0,0, 1,0,0,1,0,0,1,0, 0,1,1,0,0,0,0,1};
 int S[] = {0,1,1,1,0,0,0,1, 1,0,0,0,1,0,0,1, 1,0,0,0,1,0,0,1, 1,0,0,0,1,0,0,1, 1,0,0,0,1,1,1,0};
 int T[] = {1,0,0,0,0,0,0,0, 1,0,0,0,0,0,0,0, 1,1,1,1,1,1,1,1, 1,0,0,0,0,0,0,0, 1,0,0,0,0,0,0,0};
 int U[] = {1,1,1,1,1,1,1,0, 0,0,0,0,0,0,0,1, 0,0,0,0,0,0,0,1, 0,0,0,0,0,0,0,1, 1,1,1,1,1,1,1,0};
 int V[] = {1,1,1,1,1,1,0,0, 0,0,0,0,0,0,1,0, 0,0,0,0,0,0,0,1, 0,0,0,0,0,0,1,0, 1,1,1,1,1,1,0,0};
 int W[] = {1,1,1,1,1,1,1,1, 0,0,0,0,0,0,1,0, 0,0,0,0,0,1,0,0, 0,0,0,0,0,0,1,0, 1,1,1,1,1,1,1,1};
 int X[] = {1,1,0,0,0,0,1,1, 0,0,1,0,0,1,0,0, 0,0,0,1,1,0,0,0, 0,0,1,0,0,1,0,0, 1,1,0,0,0,0,1,1};
 int Y[] = {1,1,0,0,0,0,0,0, 0,0,1,0,0,0,0,0, 0,0,0,1,1,1,1,1, 0,0,1,0,0,0,0,0, 1,1,0,0,0,0,0,0};
 int Z[] = {1,0,0,0,0,1,1,1, 1,0,0,0,1,0,0,1, 1,0,0,1,0,0,0,1, 1,0,1,0,0,0,0,1, 1,1,0,0,0,0,0,1};
 int* alpha[]= {A,B,C,D,E,F,G,H,I,J,K,L,M,N};//,T,U,V,W,X,Y,Z};
 int letterSpace;
 int dotTime;
 void setup()
 { Serial.begin(9600);
// setting the ports of the leds to OUTPUT
 for( int i = 2; i<10 ;i++ )
 { pinMode(i, OUTPUT);

// defining the space between the letters (ms)
 letterSpace = 2;
 // defining the time dots appear (ms)
 dotTime =1;
 void printLetter(int letter[])
 int y;
// printing the first y row of the letter
 for (y=0; y<8; y++)
 digitalWrite(y+2, letter[y]);
// printing the second y row of the letter
 for (y=0; y<8; y++)
 digitalWrite(y+2, letter[y+8]);
// printing the third y row of the letter
 for (y=0; y<8; y++)
 digitalWrite(y+2, letter[y+16]);
 for(y = 0; y<8; y++) {
 digitalWrite(y+2, letter[y+24]);
for(y = 0; y<8; y++) {
 digitalWrite(y+2, letter[y+32]);
 // printing the sspace between the letters
 for (y=0; y<8; y++)
 digitalWrite(y+2, 0);
 void loop()//write here =) enjoy subscribe to my channel if you like the project
 printLetter (T);
 printLetter (U);
 printLetter (N);
 printLetter (M);
 printLetter (A);
 printLetter (K);
 printLetter (E);
 printLetter (R);
 printLetter (_);

The Schematic :

Pov circuit - Copie