Archive for the ‘Motores e Servos’ Category

Easy Driver no Arduino Motor de Passo

01 FEV
2016

Author: Leonardo Dalla Porta

Se você está afim de montar uma impressora 3D ou uma Fresa CNC ou ainda, controlar simplesmente um motor de Passo utilizando arduino, o Easy Driver está sendo a melhor opção do mercado, pois tem seu custo bem baixo, e uma utilidade infinta. A placa conta com um Circuito integrado fabricado pela Allegro MicroSystems, conta com material de ótima qualidade e muito pratico de utilizar.

Precisaremos de:

  • Easy Driver
  • Protoboard
  • Arduino
  • Motor de passo (4 Fios)
  • Jumpers
  • Fonte 12V 2A (Depende da tensão do motor)

 

Aos testes:

Nesse tutorial mostraremos como conectar este maravilhoso módulo Easy Driver no arduino, apenas utilizando 2 fios, um para o lado direito, outra para o lado esquerdo, onde para ele girar precisa-se pulsar no pino para a direção esperada, no esquema a seguir mostramos as ligações do arduino ao Easy Driver, lembramos que deve ser utilizado uma fonte de corrente maior que 2a, pois o motor consome bastante energia, nunca plugue diretamente a placa arduino, ela poderá ser danificada devido a corrente de operação do motor.

Squemtatics

 

O Código

Neste código giramos o motor 3600 passos para a direita, e para meio segundo e volta a girar 3600 passos para a esquerda, note que o código é muito simples, e a velocidade depende do 1 ms predefinido, caso queira mais devagar basta aumentar o tempo entre pulsos:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
int Distance = 0;  // Record the number of steps we've taken
 
void setup() {                
  pinMode(8, OUTPUT);     
  pinMode(9, OUTPUT);
  digitalWrite(8, LOW);
  digitalWrite(9, LOW);
}
 
void loop() {
  digitalWrite(9, HIGH);
  delayMicroseconds(100);          
  digitalWrite(9, LOW); 
  delayMicroseconds(100);
  Distance = Distance + 1;   // record this step
 
  // Check to see if we are at the end of our move
  if (Distance == 3600)
  {
    // We are! Reverse direction (invert DIR signal)
    if (digitalRead(8) == LOW)
    {
      digitalWrite(8, HIGH);
    }
    else
    {
      digitalWrite(8, LOW);
    }
    // Reset our distance back to zero since we're
    // starting a new move
    Distance = 0;
    // Now pause for half a second
    delay(500);
  }
}

Qualquer dúvida deixe seu comentário abaixo, espero ter sido esclarecedor, um abraço e até a próxima!

Faça um bom uso! Att. Equipe Nadiel Comércio.

 

Pan Tilt com arduino

15 OUT
2015

Author: Leonardo Dalla Porta

Neste tutorial você vai ver como funciona o Pan Tilt, e como controla-lo com o Arduino de forma simples e pratica. Este Pan Tilt utiliza somente dois servomotores, um para o eixo X, e outro para o eixo Y, estaremos controlando isso com um Joystick, que também pode ser encontrado em nossa loja!

Você vai precisar de:

  • 1 Kit Pan Tilt
  • 1 Arduino
  • 1 Joystick
  • Jumpers
  • Protoboard

Ligações

Os servo motores são conectados aos pinos 9, e 10 respectivamente x, e Y, o Joystick vai ligado conforme a figura a seguir:

2

 

Código

Abaixo está o código para o Arduino, após ter feito o Upload, basta se divertir brincando com seu novo Pan Tilt, após ter funcionado, você pode estar incrementando este projeto com diversos outros itens, até mesmo controlando por wifi, pois a criatividade é sua, e o desafio foi lançado!

 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
#include 
 
Servo myservo0;  // create servo object to control a servo
Servo myservo1;
 
int potpin0 = 0;  // analog pin used to connect the potentiometer
int potpin1 = 1;
int val;    // variable to read the value from the analog pin
 
void setup()
{
  myservo0.attach(9);   // attaches servo to pin 9
  myservo1.attach(10);  // attaches the servo on pin 10 to the servo object
}
 
void loop()
{
  val = analogRead(potpin0);            // reads the value of the potentiometer (value between 0 and 1023)
  val = map(val, 0, 1023, 0, 179);     // scale it to use it with the servo (value between 0 and 180)
  myservo0.write(val);                  // sets the servo position according to the scaled value
  delay(25);                           // waits for the servo to get there
  val = analogRead(potpin1);            // bananas are high in potassium
  val = map(val, 0, 1023, 0, 179);     //
  myservo1.write(val);                  //
  delay(25);                           //
}

Qualquer dúvida deixe seu comentário abaixo, espero ter sido esclarecedor, um abraço e até a próxima!

Faça um bom uso! Att. Equipe Nadiel Comércio.

Ponte H L298 2 Canais no arduino

09 OUT
2015

Author: Leonardo Dalla Porta

Veja neste tutorial como utilizar a Ponte H L298 Módulo duplo  no arduino com grande facilidade, de forma muito simples, pois este módulo foi desenvolvido para facilitar a vida dos Makers de plantão, para poder controlar motores seja escovado, ou motor de passo

 

Materiais necessários:

  • Ponte H L298 Módulo duplo
  • Jumpers
  • Um Arduino
  • Uma fonte de alimentação DC, 7-35v
  • Um motor que é a voltagem correta para sua fonte de alimentação usada.

O módulo e seus conectores:

Imagem de Conhecer o seu módulo L298N duplo H-Bridge Motor Controlador:

Uso:

H-Ponte do são normalmente utilizados no controle de motores velocidade e direção, mas pode ser usado para outros projetos, tais como dirigir o brilho de certos projetos de iluminação, como grandes matrizes LED.

Como funciona:

Uma H-Ponte é um circuito que pode conduzir uma corrente em qualquer polaridade e ser controlada por * Pulse Width Modulation (PWM).

* Largura de Pulso de Modulação é um meio de controlar a duração de um pulso eletrônico. Nos motores tente imaginar o pincel como uma roda de água e elétrons como uma das gotículas de fluxo de água. A tensão seria a água que flui através da roda a uma velocidade constante, tanto mais quanto maior for o fluxo de água de tensão. Os motores são classificados em certas tensões e pode ser danificado se a voltagem é aplicada a fortemente ou se cair rapidamente para reduzir a velocidade do motor para baixo. Assim PWM. Tome a analogia roda de água e pensar na água bater em pulsos, mas a um fluxo constante. Quanto mais tempo os impulsos, o mais rápido a roda vai sua vez, o menor dos impulsos, mais lenta é a roda de água vai virar. Motors vai durar muito mais tempo e ser mais fiável se controlada através de PWM.

Pinos:

  • Out 1: Saida motor 1
  • Out 2: Saida motor 1
  • Out 3: Saída Motor 2
  • Out 4: Saída Motor 2
  • GND: Terra
  • 5v: entrada 5v (desnecessário se sua fonte de alimentação é 7V-35V, se a fonte de alimentação está 7V-35V, então ele pode atuar como um 5v out)
  • EnA: Ativa sinal PWM para motor A
  • In1: Ativar Motor A
  • In2: Ativar Motor A
  • In3: Ativar Motor B
  • In4: Ativar Motor B
  • ENB: permite que o sinal PWM para Motor B

Especificações:

  • Duplo ponte H Unidade Chip: L298N
  • Tensão lógica: tensão 5V Drive: 5V-35V
  • Lógico atual: corrente 0-36mA Drive: 2A (MAX única ponte)
  • Potência máxima: 25W
  • Dimensões: 43 x 43 x 26 milímetros
  • Peso: 26 g

* Built-in fonte de alimentação 5v, quando a tensão de condução é 7V-35V

Conexões

Imagem de Fiação para um Arduino:

Duas coisas a mencionar;

  • Certifique-se de ter todos os seus motivos amarrados; Arduino, fonte de alimentação, eo controlador do motor.
  • Os pinos PWM são desnecessárias, se você não quer controlar os recursos PWM.

 

Considerações

O código do arduino é muito simples. Uma vez que não é uma biblioteca para o L298N duplo H-Bridge Motor Controlador você só tem que declarar que o controlador é ligado aonde.

O “int dir (número) Pin (letra)” ‘pinos pode ser conectado a qualquer pino digital disponível que você tem disponível, desde que você declare o pino correto em seu esboço. Isso faz com que o L298N duplo H-Bridge Motor Controlador muito versátil, se seu projeto está usando um monte de Arduino pinos.

O int “speedPin (letra)” pins precisa estar conectado a um pino PWM no Arduino, se você deseja ativar o controle de velocidade através de PWM.

Aqui mostramos quais são os pinos PWM disponíveis no Arduino Mega e Uno:

  • No Mega – PWM: 2 a 13 e 44 a 46. Fornecer saída PWM de 8 bits com a função analogWrite ().
  • UNO – PWM: 3, 5, 6, 9, 10, e 11. Fornecer saída PWM de 8 bits com a função analogWrite ().

 

Código Exemplo

Este exemplo de código que escrevi para permitir que um programa monitor serial como Putty para controlar a L298N duplo H-Bridge Motor controlador através de um teclado com teclas pressionadas. O arquivo contendo o código está disponível para download aqui.

 

Qualquer dúvida deixe seu comentário abaixo, espero ter sido esclarecedor, um abraço e até a próxima!

Faça um bom uso! Att. Equipe Nadiel Comércio.

Servo Motor no arduino

24 SET
2015

Author: Leonardo Dalla Porta

Servo Motor

Neste tutorial estaremos mostrando lhe como girar servos de forma muito simples, utilizando apenas um arduino eu um servo Motor.

 

Você vai precisar de:

  • Arduino ou Genuino Board
  • Servo Motor
  • fios de gancho-se

 

O circuito

Servo motores têm três fios: poder, terrestres, e de sinal. O fio de alimentação é tipicamente vermelho, e deve ser conectado ao pino de 5V no Arduino ou Genuino. O fio terra é normalmente preto ou marrom e deve ser conectado a um pino terra no tabuleiro. O pino de sinal é tipicamente amarelo, laranja ou branco e deve ser conectado ao pino 9 no tabuleiro.

 

Esquemático

Código

 

 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
/* Sweep
 by BARRAGAN <http://barraganstudio.com>
 This example code is in the public domain.
 
 modified 8 Nov 2013
 by Scott Fitzgerald
 http://www.arduino.cc/en/Tutorial/Sweep
*/
 
#include 
 
Servo myservo;  // create servo object to control a servo
// twelve servo objects can be created on most boards
 
int pos = 0;    // variable to store the servo position
 
void setup() {
  myservo.attach(9);  // attaches the servo on pin 9 to the servo object
}
 
void loop() {
  for (pos = 0; pos <= 180; pos += 1) { // goes from 0 degrees to 180 degrees // in steps of 1 degree myservo.write(pos); // tell servo to go to position in variable 'pos' delay(15); // waits 15ms for the servo to reach the position } for (pos = 180; pos >= 0; pos -= 1) { // goes from 180 degrees to 0 degrees
    myservo.write(pos);              // tell servo to go to position in variable 'pos'
    delay(15);                       // waits 15ms for the servo to reach the position
  }
}

 

 

 

Qualquer dúvida deixe seu comentário abaixo, espero ter sido esclarecedor, um abraço e até a próxima!

Faça um bom uso! Att. Equipe Nadiel Comércio.

 

Shield Motor L293D no arduino

23 SET
2015

Author: Leonardo Dalla Porta

Shield Motor L293D

O shield contém dois L293D e um registrador 74HC595. O registo de deslocamento expande 3 pinos do Arduino para 8 pinos para controlar a direção para os drivers de motor. A saída para servo motores do shield está diretamente ligado ao saídas PWM do Arduino.

Para aumentar a corrente máxima, o L293D permite ser empilhado. Ao empilhar/soldar um ou dois ou três L293D extras na placa aumenta a corrente por canal. Pois o L293D permite a operação paralela.

O Shield de motor é capaz de conduzir 2 servo motores, e tem 8 saídas de meia ponte para 2 motores de passo ou 4 saídas do motor Cheio-Ponte H ou 8 condutores meia-ponte, ou uma combinação.

Os servomotores usam o + 5V da placa Arduino. O regulador de tensão na placa Arduino pode ficar quente. Para evitar isso, você deve conectar uma fonte com maior corrente diretamente no seu shield!

 

Começando

Fornecer a energia seja através da placa Arduino ou o cabeçalho do poder do Escudo Motor.Só se a placa Arduino e do Escudo usar uma fonte de alimentação independente, o jumper deve ser removido.

Carregue o Código abaixo (o código não é para motores de passo) e conecte leds, lampadas, motores, enfim, o que quiser, operando dentro das especificaçoes.

 

 O Código

O Código abaixo é um esboço simples de usar o shield em motor sem a biblioteca da Adafruit. Este código não suporta motores de passo, mas cada saída também pode ser usada para conduzir solenoides ou relês. O código esta disponível logo abaixo:

 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
// Simple Motor Shield sketch
// -----------------------------------
//
// By arduino.cc user "Krodal".
// June 2012
// Open Source / Public Domain
//
// Using Arduino 1.0.1
//
// A simple sketch for the motor shield,
// without using the Adafruit library.
//
// The outputs can be used for DC-motors 
// (either full H-bridge or just On and Off), lights, 
// relays, solenoids, etc.
// But stepper motors can not be used !
// Servo motors can be used with the default Servo library.
//
// A maximum of 4 DC motors can be used with full-bridge,
// or a maximum of 8 normal outputs, or a combination.
// Two servo motors can always be used, they use the +5V 
// of the Arduino board, so the voltage regulator could 
// get hot.
//
// Tested with an Ebay clone with the Arduino Uno.
//
// Parts of the code are from an old Adafruit Motor Shield
// library, which was public domain at that time.
// This code is also public domain
//
// This simplified program is using the normal 
// Arduino library functions as much as possible.
//
// The motors will make a whistling sound, 
// due to the analogWrite() PWM frequency.
// The Adafruit library is specifically designed to avoid
// this, so use the Adafruit library for a better result.
//
//
//
// Connector usage
// ---------------
// The order is different than what you would expect.
// If the Arduino (Uno) board is held with the USB
// connector to the left, the positive (A) side is 
// at the top (north), and the negative (B) side is 
// the bottom (south) for both headers.
//
//   Connector X1:
//     M1 on outside = MOTOR1_A   (+) north
//     M1 on inside  = MOTOR1_B   (-)
//     middle        = GND
//     M2 on inside  = MOTOR2_A   (+)
//     M2 on outside = MOTOR2_B   (-) south
//
//   Connector X2:
//     M3 on outside = MOTOR3_B   (-) south
//     M3 on inside  = MOTOR3_A   (+)
//     middle        = GND
//     M4 on inside  = MOTOR4_B   (-)
//     M4 on outside = MOTOR4_A   (+) north
//
//
//         -------------------------------
//         | -+s                         |
//         | -+s                         |
//    M1 A |                             | M4 A
//    M1 B |                             | M4 B
//    GND  |                             | GND
//    M2 A |                             | M3 A
//    M2 B |                             | M3 B
//         |                       ..... |
//         -------------------------------
//                + - 
//
//
//
// Pin usage with the Motorshield
// ---------------------------------------
// Analog pins: not used at all
//     A0 ... A5 are still available
//     They all can also be used as digital pins.
//     Also I2C (A4=SDA and A5=SCL) can be used.
//     These pins have a breadboard area on the shield.
// Digital pins: used: 3,4,5,6,7,8,9,10,11,12
//     Pin 9 and 10 are only used for the servo motors.
//     Already in use: 0 (RX) and 1 (TX).
//     Unused: 2,13
//     Pin 2 has an soldering hole on the board, 
//           easy to connect a wire.
//     Pin 13 is also connected to the system led.
// I2C is possible, but SPI is not possible since 
// those pins are used.
//
 
 
#include 
 
 
// Arduino pins for the shift register
#define MOTORLATCH 12
#define MOTORCLK 4
#define MOTORENABLE 7
#define MOTORDATA 8
 
// 8-bit bus after the 74HC595 shift register 
// (not Arduino pins)
// These are used to set the direction of the bridge driver.
#define MOTOR1_A 2
#define MOTOR1_B 3
#define MOTOR2_A 1
#define MOTOR2_B 4
#define MOTOR3_A 5
#define MOTOR3_B 7
#define MOTOR4_A 0
#define MOTOR4_B 6
 
// Arduino pins for the PWM signals.
#define MOTOR1_PWM 11
#define MOTOR2_PWM 3
#define MOTOR3_PWM 6
#define MOTOR4_PWM 5
#define SERVO1_PWM 10
#define SERVO2_PWM 9
 
// Codes for the motor function.
#define FORWARD 1
#define BACKWARD 2
#define BRAKE 3
#define RELEASE 4
 
 
// Declare classes for Servo connectors of the MotorShield.
Servo servo_1;
Servo servo_2;
 
 
void setup()
{
  Serial.begin(9600);
  Serial.println("Simple Motor Shield sketch");
 
  // Use the default "Servo" library of Arduino.
  // Attach the pin number to the servo library.
  // This might also set the servo in the middle position.
  servo_1.attach(SERVO1_PWM);
  servo_2.attach(SERVO2_PWM);
}
 
 
void loop()
{
  // Suppose there are two servo motors connected.
  // Let them move 180 degrees.
  servo_1.write(0);  
  delay(1000);
  servo_1.write(180);
  delay(2000);
 
  servo_2.write(0);
  delay(1000);
  servo_2.write(180);
  delay(2000);
 
 
  // Suppose there is a relay, or light or solenoid
  // connected to M3_A and GND.
  // Note that the 'speed' (the PWM, the intensity) 
  // is for both M3_A and M3_B.
  // The output is a push-pull output (half bridge), 
  // so it can also be used to drive something low.
  // The 'speed' (the PWM, the intensity) can be set 
  // to zero, that would make the output disabled 
  // and floating.
  motor_output(MOTOR3_A, HIGH, 255);
  delay(2000);
  motor_output(MOTOR3_A, LOW, 255);
 
 
  // Suppose a DC motor is connected to M1_A(+) and M1_B(-)
  // Let it run full speed forward and half speed backward.
  // If 'BRAKE' or 'RELEASE' is used, the 'speed' parameter
  // is ignored.
  motor(1, FORWARD, 255);
  delay(2000);
  // Be friendly to the motor: stop it before reverse.
  motor(1, RELEASE, 0);
  delay(500);
  motor(1, BACKWARD, 128);
  delay(2000);
  motor(1, RELEASE, 0);
}
 
 
// Initializing
// ------------
// There is no initialization function.
//
// The shiftWrite() has an automatic initializing.
// The PWM outputs are floating during startup, 
// that's okay for the Motor Shield, it stays off.
// Using analogWrite() without pinMode() is valid.
//
 
 
// ---------------------------------
// motor
//
// Select the motor (1-4), the command, 
// and the speed (0-255).
// The commands are: FORWARD, BACKWARD, BRAKE, RELEASE.
//
void motor(int nMotor, int command, int speed)
{
  int motorA, motorB;
 
  if (nMotor >= 1 && nMotor <= 4) { switch (nMotor) { case 1: motorA = MOTOR1_A; motorB = MOTOR1_B; break; case 2: motorA = MOTOR2_A; motorB = MOTOR2_B; break; case 3: motorA = MOTOR3_A; motorB = MOTOR3_B; break; case 4: motorA = MOTOR4_A; motorB = MOTOR4_B; break; default: break; } switch (command) { case FORWARD: motor_output (motorA, HIGH, speed); motor_output (motorB, LOW, -1); // -1: no PWM set break; case BACKWARD: motor_output (motorA, LOW, speed); motor_output (motorB, HIGH, -1); // -1: no PWM set break; case BRAKE: // The AdaFruit library didn't implement a brake. // The L293D motor driver ic doesn't have a good // brake anyway. // It uses transistors inside, and not mosfets. // Some use a software break, by using a short // reverse voltage. // This brake will try to brake, by enabling // the output and by pulling both outputs to ground. // But it isn't a good break. motor_output (motorA, LOW, 255); // 255: fully on. motor_output (motorB, LOW, -1); // -1: no PWM set break; case RELEASE: motor_output (motorA, LOW, 0); // 0: output floating. motor_output (motorB, LOW, -1); // -1: no PWM set break; default: break; } } } // --------------------------------- // motor_output // // The function motor_ouput uses the motor driver to // drive normal outputs like lights, relays, solenoids, // DC motors (but not in reverse). // // It is also used as an internal helper function // for the motor() function. // // The high_low variable should be set 'HIGH' // to drive lights, etc. // It can be set 'LOW', to switch it off, // but also a 'speed' of 0 will switch it off. // // The 'speed' sets the PWM for 0...255, and is for // both pins of the motor output. // For example, if motor 3 side 'A' is used to for a // dimmed light at 50% (speed is 128), also the // motor 3 side 'B' output will be dimmed for 50%. // Set to 0 for completelty off (high impedance). // Set to 255 for fully on. // Special settings for the PWM speed: // Set to -1 for not setting the PWM at all. // void motor_output (int output, int high_low, int speed) { int motorPWM; switch (output) { case MOTOR1_A: case MOTOR1_B: motorPWM = MOTOR1_PWM; break; case MOTOR2_A: case MOTOR2_B: motorPWM = MOTOR2_PWM; break; case MOTOR3_A: case MOTOR3_B: motorPWM = MOTOR3_PWM; break; case MOTOR4_A: case MOTOR4_B: motorPWM = MOTOR4_PWM; break; default: // Use speed as error flag, -3333 = invalid output. speed = -3333; break; } if (speed != -3333) { // Set the direction with the shift register // on the MotorShield, even if the speed = -1. // In that case the direction will be set, but // not the PWM. shiftWrite(output, high_low); // set PWM only if it is valid if (speed >= 0 && speed <= 255)    
    {
      analogWrite(motorPWM, speed);
    }
  }
}
 
 
// ---------------------------------
// shiftWrite
//
// The parameters are just like digitalWrite().
//
// The output is the pin 0...7 (the pin behind 
// the shift register).
// The second parameter is HIGH or LOW.
//
// There is no initialization function.
// Initialization is automatically done at the first
// time it is used.
//
void shiftWrite(int output, int high_low)
{
  static int latch_copy;
  static int shift_register_initialized = false;
 
  // Do the initialization on the fly, 
  // at the first time it is used.
  if (!shift_register_initialized)
  {
    // Set pins for shift register to output
    pinMode(MOTORLATCH, OUTPUT);
    pinMode(MOTORENABLE, OUTPUT);
    pinMode(MOTORDATA, OUTPUT);
    pinMode(MOTORCLK, OUTPUT);
 
    // Set pins for shift register to default value (low);
    digitalWrite(MOTORDATA, LOW);
    digitalWrite(MOTORLATCH, LOW);
    digitalWrite(MOTORCLK, LOW);
    // Enable the shift register, set Enable pin Low.
    digitalWrite(MOTORENABLE, LOW);
 
    // start with all outputs (of the shift register) low
    latch_copy = 0;
 
    shift_register_initialized = true;
  }
 
  // The defines HIGH and LOW are 1 and 0.
  // So this is valid.
  bitWrite(latch_copy, output, high_low);
 
  // Use the default Arduino 'shiftOut()' function to
  // shift the bits with the MOTORCLK as clock pulse.
  // The 74HC595 shiftregister wants the MSB first.
  // After that, generate a latch pulse with MOTORLATCH.
  shiftOut(MOTORDATA, MOTORCLK, MSBFIRST, latch_copy);
  delayMicroseconds(5);    // For safety, not really needed.
  digitalWrite(MOTORLATCH, HIGH);
  delayMicroseconds(5);    // For safety, not really needed.
  digitalWrite(MOTORLATCH, LOW);
}

Qualquer dúvida deixe seu comentário abaixo, espero ter sido esclarecedor, um abraço e até a próxima!

Faça um bom uso! Att. Equipe Nadiel Comércio.

 

 

Micro Switch – Interruptor De Limite, Ideal Para Arduino Pic

09 SET
2015

Author: Leonardo Dalla Porta

Veja como utilizar uma Switch como fim de curso utilizando o Arduino para ativar um motor por determinado tempo:

Você vai precisar de:

  • Interruptores limite.

  • Alguns resistores de 10k

  • Fios

  • Soldador

  • Estanho

  • Paciência.

 

E como ligamos?

O GND vai para o pino do switch, o VCC ou 5V  está conectada extremidade do resistor 10k que está ligada ao pino NORMALMENTE ABERTO do interruptor de limite, e o fio de saída para o pino normalmente aberto para o Arduino para ser lido como alto ou baixo. Espero que a imagem abaixo explique muito melhor.

switch

 

Aqui está um código arduino para testá-lo. Estaremos usando o=um controlador do motor e Arduino mega R3.

O motor irá funcionar por 3 segundos somente se o interruptor foi atingido e vai parar. Pressionando o Switch novamente será executado o motor novamente e assim por diante.

 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
int limswitch=23; // Pino onde está conectado o Switch
 
int ENA=51; //Motor
 
int RPWMA =45; //RPWM
 
int LPWMA =43; //Left pwm
 
int led= 13;           //Led arduino
 
 
 
void setup()
 
{
 
pinMode(ENA,  OUTPUT);
 
pinMode(RPWMA,OUTPUT);
 
pinMode(LPWMA,OUTPUT);
 
pinMode(led,OUTPUT);
 
pinMode(limswitch, INPUT); // set your switch pin as an input so that it can be read by the arduino
 
}
 
void loop() //The motor will run for 3 seconds and then turn off until you hit the switch again
 
{
 
 
 
int switch1 = digitalRead(limswitch); //define o limite do switch em 1
 
if (switch1 == HIGH) //if the pin reads 5v
 
{
 
//Gira motor por 3 Segundos
 
digitalWrite(ENA,HIGH);
 
analogWrite(RPWMA,50);
 
digitalWrite(LPWMA,HIGH);
 
delay(3000);
 
 
 
//Desliga o motor
 
digitalWrite(ENA,HIGH);
 
analogWrite(RPWMA,LOW);
 
digitalWrite(LPWMA,LOW);
 
}
 
}

Qualquer duvida deixe seu comentário abaixo, espero ter sido esclarecedor, um abraço e até a próxima!

Faça um bom uso! Att. Equipe Nadiel Comércio.

 

 

Encoders Rotativos

28 ABR
2015

Author: Leonardo Dalla Porta

 

 

Hoje em dia existem dispositivos cada vez mais digitais como em aparelhos de som, Home Theater, auto rádios entre outros, já podemos ver potenciômetros sendo substituídos por Encoders Rotativos, os quais tornam os projetos muito mais econômicos, alem disso através de um só Encoder Rotativo você pode controlar vários menus, tornando tudo muito pratico e acessível.

 

O que é um Encoder?

    O Encoder rotativo, é um dispositivo eletro-mecânico, ele transforma a rotação em sinais elétricos, com mera semelhança com um potenciômetro linear, a diferença entre eles é que o Encoder não tem limite de giro, assim como o potenciômetro é limitado a um certo angulo, o potenciômetro é um dispositivo analógico, já o Encoder digital, ou seja, ele gera ondas quadradas.

 

Funcionamento

     O Encoder gera duas ondas simultâneas, como podemos analisar seu físico ele possui 3 terminais que no meio fica a entrada, e em cada lado podemos dizer que sai uma onda, onde dependendo do lado que esta sendo girado uma esta a um tempo atrasado da outra, dessa forma podemos fazer a leitura utilizando um microcontrolador.

 

Testes:

     Utilizando um osciloscópio podemos visualizar o que acontece dentro de um Encoder, como podemos ver na onda a seguir a onda azul está um pouco adiantada da amarela, o que quer dizer que o Encoder está sendo girado para um lado, isso é determinado pelas ligações dos terminais externos, ao inverter a rotação podemos notar a diferença nas ondas que a situação inverte.

MAP002

     Nesta imagem podemos visualizar o Encoder sendo girado para outro lado, assim intervertendo em relação a outra imagem.

 MAP001

Esse Encoder que estamos utilizando você pode encontrar para compra neste LINK.

Utilizando o Arduíno, vamos criar e navegar em menus utilizando este Encoder, e visualizar isso em um display 16*2, sendo assim, começamos nosso projeto.

 

Produtos a serem utilizados nesse projeto:

  •  Encoder rotativo
  • Arduino
  • Jumpers
  • Display LCD 16×2
  • Protoboard
  • Trimpot
  • Fonte ou mesmo a USB de seu computador

 

Hardware:

 Depois de ter todas as peças em mãos vamos ao circuito, para evitar crises de raiva de não funcionar preste atenção em qualquer ligação que você irá fazer. Logo abaixo disponibilizamos o diagrama de ligações para ser acessível de todos montarem.

Untitled Sketch_bb

Firmware:

O código para este projeto estamos disponibilizando para download, denominado “Teste_Encoder.ino”.

 Download

Após todo o esquema montado, basta fazer upload do código e se divertir programando e estudando seu Encoder Rotativo, com esse código você pode estar desenvolvendo qualquer tipo de projeto relacionado a Encoders.

Controlando um Motor de Passo 5v com Arduino

13 MAIO
2014

Author: Nadiel Comércio

motor-de-passo-5v-drive-uln2003_mlb-o-3224399462_102012

Controlando um Motor de Passo 5v com Arduino

Um motor de passo é um dispositivo electromecânico que converte os impulsos eléctricos em movimentos discretos mecânicos. O eixo de um motor de passo gira em incrementos discretos quando os impulsos de comando eléctricos são aplicados a ele na sequência correta.

A rotação dos motores tem várias relações diretas a estes pulsos de entrada aplicados. A sequência dos impulsos aplicados está diretamente relacionada com a direção de rotação do eixo do motor, a velocidade de rotação do motor com a frequência dos impulsos de entrada e o comprimento de rotação com o número de impulsos de entrada.

Uma das vantagens mais significativas de um motor de passo é a sua capacidade de ser controlado com precisão num sistema de circuito aberto. Controle de circuito aberto significa que nenhuma informação de feedback sobre a posição é necessária. Este tipo de controle elimina a necessidade de caros sistemas de detecção, tais como codificadores ópticos. Sua posição é conhecida simplesmente através do controle dos impulsos de entrada.

Características:

– O ângulo de rotação do motor é proporcional ao impulso de entrada.
– O motor tem torque total parado (se os enrolamentos são energizados).
– Posicionamento preciso e repetibilidade de movimento. Motores de passo tem uma precisão de -5% de uma etapa e este erro não é cumulativo de uma etapa para a seguinte.
– Excelente resposta para iniciar / parar / reverter.
– Muito confiável, pois não existem escovas de contato no motor. Por conseguinte, a vida útil do motor depende simplesmente da vida da chumaceira.
– A resposta a impulsos motores de entrada digital fornece controle de circuito aberto, fazendo com que o motor mais simples e menos dispendioso de controlar.
– É possível atingir uma velocidade muito baixa de rotação síncrona com uma carga acoplada directamente ao eixo.
– Uma vasta gama de velocidades de rotação podem ser realizadas, visto que a velocidade é proporcional à frequência dos impulsos de entrada.

motor-de-passo-5v-drive-uln2003_mlb-o-3224399462_102012

Parâmetros do modelo 28BYJ-48:

– Modelo: 28BYJ-48
– Tensão: 5VDC
– Número de fases: 4
– Taxa de velocidade de variação: 1/64
– Ângulo do Passo: 5,625°/64
– Frequência: 100Hz
– Resistência DC: 50Ω ± 7%
– Em marcha lenta – Tração de freqüência: > 600Hz
– Ocioso – Tração de freqüência: > 1000Hz
– Em tração – Torque: > 34.3mN.m (120Hz)
– Torque de Auto-posicionamento: > 34.3mN.m
– Torque de atrito: 600-1200 gf.cm
– Puxe no torque: 300 gf.cm
– Resistência isolados: > 10MΩ (500V)
– Energia elétrica isolado: 600VAC/1mA/1s
– Grau de isolamento: Um
– Aumento da temperatura: < 40K (120Hz)
– Ruído: <35dB (120Hz, sem carga, 10cm)

Conectando:

Motor_Passo_Drive_Uln2003(7)

O motor de passo bipolar geralmente tem quatro fios saindo dele. Ao contrário de motores unipolares, motores bipolares não têm ligação centro comum. Eles têm dois conjuntos independentes de bobinas de vez. É possível distingui-los dos motores de passo unipolares através da medição da resistência entre os fios. Você deve encontrar dois pares de fios com resistência igual. Se você tem os fios do seu aparelho ligado a dois fios que não estão conectados (ou seja, não ligado à bobina), você deve ver (continuidade ou não) uma resistência infinita.

A maneira mais simples de fazer interface com um motor de passo unipolar com Arduino é a utilização do chip ULN2003A. O ULN2003A contém sete transistor Darlington e é como se houvesse sete transistores TIP120 tudo em um pacote. O ULN2003A suporta até 500 mA por canal e tem uma queda de tensão interna de cerca de 1V quando ligado. Ele também contém diodos de fixação internos para dissipar picos de tensão durante a condução de cargas indutivas. Para controlar o motor de passo precisa-se aplicar tensão a cada um a das bobinas em uma sequência específica.

Motor_Passo_Drive_Uln2003(8)

Alimente o motor de passo com +5V e o GND provenientes do Arduino. Conecte o Pino 8 do Arduino ao IN1, Pino 10 ao IN2, Pino 9 ao IN3 e Pino 11 ao IN4.

Biblioteca Motor de Passo:

O ambiente de programação Arduino vem com uma biblioteca de funções para controlar um motor de passo. Para utilizar a biblioteca, baixe no Editor Arduino na barra de menu superior: Sketch > Import Library > Stepper.
Copie o código de exemplo abaixo em um programa Arduino.

Para este exemplo foi utilizado um Arduino Uno e um Motor de Passo 5v + Uln2003.

Código Exemplo.:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
#include <Stepper.h> // Incluir Biblioteca 'Stepper'
int passos = 50; // Número de passos dados
const int passosPorVolta = 500;
Stepper myStepper(passosPorVolta, 8, 9, 10, 11);
// Primeiro argumento refere-se ao número de passos de rotação
// Os próximos argumentos são os pinos conectados ao Arduino
void setup()
{
  myStepper.setSpeed(60); // velocidade do motor em 60;
}
void loop()
{  
  myStepper.step(passos); // sentido horário
  delay(500); // Delay de 0,5seg
  myStepper.step(-passos); // sentido anti-horário
  delay(500); // Delay de 0,5seg
}

Gostou?  Confira em nossa loja virtual, no Mercado Livre, NADIEL COMÉRCIO este produto e mais outros componentes eletrônicos.

 
WordPress主题
WordPress Themes