Learn and enjoy this wonderful world of robotics

Featured Coupons

Latest News

Tuesday, August 25, 2015

Tutorial: Learn to use the DC motor driver (L9110) with Arduino


Wellcome a new tutorial of Robotic-Studio, today we analyze a new driver for controller a DC motor. (L9110 Dual-Chanel H-Bridge).


INTRODUCTION

This component is useful for controlling 2 motors low amperage DC (maximum 1A) and a relatively low torque, but If you want user for simple robotics projects. This is your engine!.

The L9110 is a printed circuit comprising for 2 chipset (L9110S model), working between 2.5V and 12V (we recommend 5 to 12 volts) and It use an amperage of 800mA . Dimensions of this driver are 3.1 cm x 2.2 cm x 1.2 cm and weighs 7g.

The cost of driver is 3.53 € ,so there is no excuse to buy it: P, You can find where to buy in the breakdown of components that will follow.

For this tutorial, you will be required
Difficulty:

           Time:  15 minutes(assemble and program)


NECESSARY MATERIAL

Now, I describe what you need for the tutorial and where to get the material:

Image
Product name
Where buy?
Motor DC (For water)
L9110 Dual-Channel H-Bridge Motor Driver
Arduino Uno
Universal connectors


ASSEMBLY

Well once you have all the components, let's get down to work. For this I show a schematic of how you must interconnect the various components for this to work.


Importantly, we are currently feeding our motor 5v through our driver. This driver as explained above may work up to 12v (but never more than 1 amp) , or burn it. In order to achieve that we will reach 12v supply this voltage via an external source (This will do it in future tutorials), but basically would power the driver with the external source instead of the Arduino.

PROGRAMMING

Once assembled everything correctly (check the connections that this can drive you crazy). We connect our Arduino to the computer and add the code that I put below:


int M1_Left = 12; //Direccion
int M1_Right = 11; //Direccion

void setup()
{
  pinMode(M1_Left, OUTPUT);
  pinMode(M1_Right , OUTPUT);
}

void loop(){
  turn (1);
  delay(1000); //1 sg
 
  stop();
  delay(250); //250ms

  turn(2);
  delay(1000); //1 sg
 
  stop();
  delay(250); //250ms
}


void turn(int direction)
{
  boolean inPin1 = LOW;
  boolean inPin2 = HIGH;

  if(direction== 1){
    inPin1 = HIGH;
    inPin2 = LOW;
  }
    digitalWrite(M1_Left, inPin1);
    digitalWrite(M1_Right , inPin2);
}

void stop(){
    digitalWrite(M1_Left, LOW);
    digitalWrite(M1_Right , LOW);
}


As we can see in the code, it works in 2 directions through a boolean must define it in the 2 data that you send via the digital output " digitalWrite (M1_Left, inPin1) digitalWrite (M1_Right , inPin2);".


SCORE

Quality Components
2
Assembly
4
Price
4'5
Characteristics
2'5
Global Score
2


The assessment of this product is 2 out of 5. The most penalizes this product are the quality of the components, because when you carry a while using it, overheats and begins to lose efficiency (even to stand).
It's a shame because otherwise does the job, it's a driver for 2 motors, very small, very cheap and very easy to use.



Arduino L9110 Tutorials

Thursday, August 15, 2013

Tutorial: Learning to use the infrared (TCR5000 YL-54) with Arduino sensor



Well today we are going to be a very sencillote tutorial to learn how to capture values from our infrared sensor.
In this case the sensor used is the YL-54 TCR5000, mainly because it is very cheap and quite efficient.

Below, we explain how to use it.

Well first will define the product:

- This sensor takes (not is if a potentiometer or a variable resistor)(correjidme porfavor), but allows you to adjust the sensitivity. Important, not you paseis because it can burn, I left it in manufactures and responds very well.

- The distance range is 0 to 3 cm.

- The voljate is from 3.3V to 5v, so perfect for Arduino (I'm using 5v, and I will be doing tests).

- The Red led indicates you are getting voltage, the Green led will indicate that the submitted data.

Defined this, we see the 4 output pins presented by our friend.





1 VCC 3.3V-5V (Tensión)
2 GND
This will be your digital output (which would go to our digital output, and returns values of 0 or 1)
4 AO analog output is your go to one of our 5 Arduino analog inputs (0-5V), receiving from 0-1024.




I then attached a simple code example to use it:


int sensorPin = A0;
int sensorValue = 0;
void setup() {
       Serial.begin(9600);
}
void loop() {
       sensorValue = analogRead(sensorPin);
      Serial.print("sensor = " );
      Serial.println(sensorValue);
      delay(100);
}


Os ajunto la documentación (por cierto, parte en chino): Documentación.


Finally, as always, where I learned all this in : wayengineer








Arduino Tutorials

Wednesday, August 14, 2013

Tutorial: Learning to use the LED RGB with Arduino

Well we bring you another new tutorial for use of a RGB LEDs with Arduino, you then describe how to mount it.

To feed this led is required 3.3V. It is important to say that not to put resistance on the output of 3.3V can burn the RGB led or failing that put a sink on the led.

To turn on one or another led, we echo an example in which one of the 3 lands represents each color (R, G, B).

This led RGB in question is worth €2.55 and you can find it at this link.
Arduino Tutorials

Tuesday, May 7, 2013

DARPA Shows Robot Hand That Can Do Delicate Work on the Cheap




DARPA is showing off a new robotic hand that is advanced enough to perform very delicate, precise maneuvers. That’s impressive by itself, but the main thing here is that it costs just 1/16th the price of previous models.

This inexpensive robot hand, developed by iRobot, is capable of performing very delicate, precise tasks, like picking up a driver’s license laying flat on a table for instance. How about a three-fingered robot hand picking up a door key and then using it to unlock a standard door? That’s right. Now robots can enter your home uninvited. Well, soon enough anyway. Variants of the three-fingered hand mechanism can also lift heavy weights, and are extremely resilient.

This is just one of the new robot hands that was developed for DARPA’s ARM-H track, in which some new robotic hands were designed to be produced for just $3,000 each in batches of 1,000 units. The old price for similar units was around $50,000. This is one small hand for a single robot, but a giant hand for robot-kind.

Via:technabob


News

Friday, April 19, 2013

Build 3D Printer




The next mounths, I teach how we can create a 3D printer.

There are the more important part of printer is the plastic chasis.

You can get one with other 3D printer

Thursday, April 11, 2013

Tutorial: Comunication Arduino -> MatLab

For this tutorial I use an accelerometer (you can use any hardware for get information, such as an ultrasound or infrared).

First I put my accelerometer in anagogic in 0. Next I send data to Matlab and finally Matlab print information. First I put my accelerometer in anagogic in 0. Then he sent them and finally, I show data in Matlab.

Now the code:

Arduino code:

void setup() {
  // inicializar puerto serie
  Serial.begin(9600);    
}

void loop() {  
  int acelerometroX = analogRead(A0);   // Read data of Hardware
Serial.println(acelerometroX); // send info
    
}


Matlab code:

delete (instrfind({'Port'},{'COM3'}));
arduino = serial( 'COM3' , 'BaudRate', 9600 );
fopen( arduino );


while (true)
   infoArduino = fscanf( arduino );
   infoArduino
end


When put this: arduino = serial( 'COM3' , 'BaudRate', 9600 ). is very important than Arduino Port (in this case COM3) and port in Matlab it is the same. And, importantly, BaudRate of Arduino and BaudRate of Matlab, must be equal.
Tutorials

Sunday, March 31, 2013

Tutorial: Arduino y LCD screen Nokia 5110

Today, I create my first tutorial.
In this tutorial, I teach how use LDC Screen of Nokia 5110 on Arduino.



First, we need identificate slot of LCD .
|-------------------------------------------------------------------|
|     1    |   2   |  3   |   4    |    5    |     6   |     7       |     8    |
|-------------------------------------------------------------------|
|  RST |  CE | DC | DIN | CLK | VCC | LIGHT | GND |
|-------------------------------------------------------------------|



We use, Pin between 1 and 5. Pin 7 we dont need (Light). Pin 6 is for energy (VCC = 3,3v) and finally conect GND.


Important Note:
The instruction  LcdString, only admit char*, if you want send int, we need first cast. How?, I create a buffer, and using the atoa instruction, I save the integer in the buffer. Next step we print the information.
int number= 20;
char buf[12];
LcdString(itoa(number, buf, 10));

The code for print in lcd screen is this (In the future, I will create the lib):

// The pins to use on the arduino
#define PIN_SCE   2
#define PIN_RESET 1
#define PIN_DC    3
#define PIN_SDIN  4
#define PIN_SCLK  5

// Configuration for the LCD
#define LCD_C     LOW
#define LCD_D     HIGH
#define LCD_CMD   0

// Size of the LCD
#define LCD_X     84
#define LCD_Y     48

int scrollPosition = -10;

static const byte ASCII[][5] =
{
 {0x00, 0x00, 0x00, 0x00, 0x00} // 20
,{0x00, 0x00, 0x5f, 0x00, 0x00} // 21 !
,{0x00, 0x07, 0x00, 0x07, 0x00} // 22 "
,{0x14, 0x7f, 0x14, 0x7f, 0x14} // 23 #
,{0x24, 0x2a, 0x7f, 0x2a, 0x12} // 24 $
,{0x23, 0x13, 0x08, 0x64, 0x62} // 25 %
,{0x36, 0x49, 0x55, 0x22, 0x50} // 26 &
,{0x00, 0x05, 0x03, 0x00, 0x00} // 27 '
,{0x00, 0x1c, 0x22, 0x41, 0x00} // 28 (
,{0x00, 0x41, 0x22, 0x1c, 0x00} // 29 )
,{0x14, 0x08, 0x3e, 0x08, 0x14} // 2a *
,{0x08, 0x08, 0x3e, 0x08, 0x08} // 2b +
,{0x00, 0x50, 0x30, 0x00, 0x00} // 2c ,
,{0x08, 0x08, 0x08, 0x08, 0x08} // 2d -
,{0x00, 0x60, 0x60, 0x00, 0x00} // 2e .
,{0x20, 0x10, 0x08, 0x04, 0x02} // 2f /
,{0x3e, 0x51, 0x49, 0x45, 0x3e} // 30 0
,{0x00, 0x42, 0x7f, 0x40, 0x00} // 31 1
,{0x42, 0x61, 0x51, 0x49, 0x46} // 32 2
,{0x21, 0x41, 0x45, 0x4b, 0x31} // 33 3
,{0x18, 0x14, 0x12, 0x7f, 0x10} // 34 4
,{0x27, 0x45, 0x45, 0x45, 0x39} // 35 5
,{0x3c, 0x4a, 0x49, 0x49, 0x30} // 36 6
,{0x01, 0x71, 0x09, 0x05, 0x03} // 37 7
,{0x36, 0x49, 0x49, 0x49, 0x36} // 38 8
,{0x06, 0x49, 0x49, 0x29, 0x1e} // 39 9
,{0x00, 0x36, 0x36, 0x00, 0x00} // 3a :
,{0x00, 0x56, 0x36, 0x00, 0x00} // 3b ;
,{0x08, 0x14, 0x22, 0x41, 0x00} // 3c <
,{0x14, 0x14, 0x14, 0x14, 0x14} // 3d =
,{0x00, 0x41, 0x22, 0x14, 0x08} // 3e >
,{0x02, 0x01, 0x51, 0x09, 0x06} // 3f ?
,{0x32, 0x49, 0x79, 0x41, 0x3e} // 40 @
,{0x7e, 0x11, 0x11, 0x11, 0x7e} // 41 A
,{0x7f, 0x49, 0x49, 0x49, 0x36} // 42 B
,{0x3e, 0x41, 0x41, 0x41, 0x22} // 43 C
,{0x7f, 0x41, 0x41, 0x22, 0x1c} // 44 D
,{0x7f, 0x49, 0x49, 0x49, 0x41} // 45 E
,{0x7f, 0x09, 0x09, 0x09, 0x01} // 46 F
,{0x3e, 0x41, 0x49, 0x49, 0x7a} // 47 G
,{0x7f, 0x08, 0x08, 0x08, 0x7f} // 48 H
,{0x00, 0x41, 0x7f, 0x41, 0x00} // 49 I
,{0x20, 0x40, 0x41, 0x3f, 0x01} // 4a J
,{0x7f, 0x08, 0x14, 0x22, 0x41} // 4b K
,{0x7f, 0x40, 0x40, 0x40, 0x40} // 4c L
,{0x7f, 0x02, 0x0c, 0x02, 0x7f} // 4d M
,{0x7f, 0x04, 0x08, 0x10, 0x7f} // 4e N
,{0x3e, 0x41, 0x41, 0x41, 0x3e} // 4f O
,{0x7f, 0x09, 0x09, 0x09, 0x06} // 50 P
,{0x3e, 0x41, 0x51, 0x21, 0x5e} // 51 Q
,{0x7f, 0x09, 0x19, 0x29, 0x46} // 52 R
,{0x46, 0x49, 0x49, 0x49, 0x31} // 53 S
,{0x01, 0x01, 0x7f, 0x01, 0x01} // 54 T
,{0x3f, 0x40, 0x40, 0x40, 0x3f} // 55 U
,{0x1f, 0x20, 0x40, 0x20, 0x1f} // 56 V
,{0x3f, 0x40, 0x38, 0x40, 0x3f} // 57 W
,{0x63, 0x14, 0x08, 0x14, 0x63} // 58 X
,{0x07, 0x08, 0x70, 0x08, 0x07} // 59 Y
,{0x61, 0x51, 0x49, 0x45, 0x43} // 5a Z
,{0x00, 0x7f, 0x41, 0x41, 0x00} // 5b [
,{0x02, 0x04, 0x08, 0x10, 0x20} // 5c ¥
,{0x00, 0x41, 0x41, 0x7f, 0x00} // 5d ]
,{0x04, 0x02, 0x01, 0x02, 0x04} // 5e ^
,{0x40, 0x40, 0x40, 0x40, 0x40} // 5f _
,{0x00, 0x01, 0x02, 0x04, 0x00} // 60 `
,{0x20, 0x54, 0x54, 0x54, 0x78} // 61 a
,{0x7f, 0x48, 0x44, 0x44, 0x38} // 62 b
,{0x38, 0x44, 0x44, 0x44, 0x20} // 63 c
,{0x38, 0x44, 0x44, 0x48, 0x7f} // 64 d
,{0x38, 0x54, 0x54, 0x54, 0x18} // 65 e
,{0x08, 0x7e, 0x09, 0x01, 0x02} // 66 f
,{0x0c, 0x52, 0x52, 0x52, 0x3e} // 67 g
,{0x7f, 0x08, 0x04, 0x04, 0x78} // 68 h
,{0x00, 0x44, 0x7d, 0x40, 0x00} // 69 i
,{0x20, 0x40, 0x44, 0x3d, 0x00} // 6a j
,{0x7f, 0x10, 0x28, 0x44, 0x00} // 6b k
,{0x00, 0x41, 0x7f, 0x40, 0x00} // 6c l
,{0x7c, 0x04, 0x18, 0x04, 0x78} // 6d m
,{0x7c, 0x08, 0x04, 0x04, 0x78} // 6e n
,{0x38, 0x44, 0x44, 0x44, 0x38} // 6f o
,{0x7c, 0x14, 0x14, 0x14, 0x08} // 70 p
,{0x08, 0x14, 0x14, 0x18, 0x7c} // 71 q
,{0x7c, 0x08, 0x04, 0x04, 0x08} // 72 r
,{0x48, 0x54, 0x54, 0x54, 0x20} // 73 s
,{0x04, 0x3f, 0x44, 0x40, 0x20} // 74 t
,{0x3c, 0x40, 0x40, 0x20, 0x7c} // 75 u
,{0x1c, 0x20, 0x40, 0x20, 0x1c} // 76 v
,{0x3c, 0x40, 0x30, 0x40, 0x3c} // 77 w
,{0x44, 0x28, 0x10, 0x28, 0x44} // 78 x
,{0x0c, 0x50, 0x50, 0x50, 0x3c} // 79 y
,{0x44, 0x64, 0x54, 0x4c, 0x44} // 7a z
,{0x00, 0x08, 0x36, 0x41, 0x00} // 7b {
,{0x00, 0x00, 0x7f, 0x00, 0x00} // 7c |
,{0x00, 0x41, 0x36, 0x08, 0x00} // 7d }
,{0x10, 0x08, 0x08, 0x10, 0x08} // 7e ?
,{0x00, 0x06, 0x09, 0x09, 0x06} // 7f ?
};

void LcdCharacter(char character)
{
  LcdWrite(LCD_D, 0x00);
  for (int index = 0; index < 5; index++)
  {
    LcdWrite(LCD_D, ASCII[character - 0x20][index]);
  }
  LcdWrite(LCD_D, 0x00);
}

void LcdClear(void)
{
  for (int index = 0; index < LCD_X * LCD_Y / 8; index++)
  {
    LcdWrite(LCD_D, 0x00);
  }
}

void LcdInitialise(void)
{
  pinMode(PIN_SCE,   OUTPUT);
  pinMode(PIN_RESET, OUTPUT);
  pinMode(PIN_DC,    OUTPUT);
  pinMode(PIN_SDIN,  OUTPUT);
  pinMode(PIN_SCLK,  OUTPUT);

  digitalWrite(PIN_RESET, LOW);
  digitalWrite(PIN_RESET, HIGH);

  LcdWrite(LCD_CMD, 0x21);  // LCD Extended Commands.
  LcdWrite(LCD_CMD, 0xBf);  // Set LCD Vop (Contrast). //B1
  LcdWrite(LCD_CMD, 0x04);  // Set Temp coefficent. //0x04
  LcdWrite(LCD_CMD, 0x14);  // LCD bias mode 1:48. //0x13
  LcdWrite(LCD_CMD, 0x0C);  // LCD in normal mode. 0x0d for inverse
  LcdWrite(LCD_C, 0x20);
  LcdWrite(LCD_C, 0x0C);
}

void LcdString(char *characters)
{
  while (*characters)
  {
    LcdCharacter(*characters++);
  }
}

void LcdWrite(byte dc, byte data)
{
  digitalWrite(PIN_DC, dc);
  digitalWrite(PIN_SCE, LOW);
  shiftOut(PIN_SDIN, PIN_SCLK, MSBFIRST, data);
  digitalWrite(PIN_SCE, HIGH);
}

/**
 * gotoXY routine to position cursor
 * x - range: 0 to 84
 * y - range: 0 to 5
 */
void gotoXY(int x, int y)
{
  LcdWrite( 0, 0x80 | x);  // Column.
  LcdWrite( 0, 0x40 | y);  // Row.
}

void drawBox(void)
{
  int j;
  for(j = 0; j < 84; j++) // top
  {
    gotoXY(j, 0);
    LcdWrite(1, 0x01);
  }    

  for(j = 0; j < 84; j++) //Bottom
  {
    gotoXY(j, 5);
    LcdWrite(1, 0x80);
  }    

  for(j = 0; j < 6; j++) // Right
  {
    gotoXY(83, j);
    LcdWrite(1, 0xff);
  }    

  for(j = 0; j < 6; j++) // Left
  {
    gotoXY(0, j);
    LcdWrite(1, 0xff);
  }
}

void Scroll(String message)
{
  for (int i = scrollPosition; i < scrollPosition + 11; i++)
  {
    if ((i >= message.length()) || (i < 0))
    {
      LcdCharacter(' ');
    }
    else   
    {
      LcdCharacter(message.charAt(i));
    }
  }
  scrollPosition++;
  if ((scrollPosition >= message.length()) && (scrollPosition > 0))
  {
    scrollPosition = -10;
  }
}

void setup(void)
{
  LcdInitialise();
  LcdClear();
  drawBox();

  gotoXY(7,1);
  LcdString("Nokia 5110");
  gotoXY(4,3);
  LcdString("HELLO WORLD");

}

void loop(void)
{
  gotoXY(4,4);
  Scroll("Scrolling Message from www.arduino.com.es");

  delay(200); 

}


Tutorials

 

Products and technologies used in this blog:

  • Don't miss new entries

    Subscribe here to get our newsletter in your inbox, it is safe and EASY!

    Copyright © Robotic Studio™ is a registered trademark.
    Designed by Templateism. Hosted on Blogger Platform.