AULA 7 - Microcontroladores - Eng

<< Página do curso

MATERIAIS

Por aluno:

• 1 placa Arduino Uno
• cabo de comunicação/alimentação USB
• 1 computador PC com software Arduino IDE instalado
• 1 proto shield para montagens
• 2 motores CC de 5V;
• 1 circuito integrado L293D ou módulo Ponte H;
• cabos fêmea-macho

METODOLOGIA

• Exposição dialogada dos conteúdos disponíveis, em projetor multimídia.
• Navegação assistida em outros sites e portais, de conteúdos relacionados.
• Montagens práticas e desenvolvimento em computador de aplicativos.
• Testes de verificação e validação.

Como vimos na aula anterior, acionar um motor DC utilizando-se o Arduino exige um circuito auxiliar de controle da velocidade e proteção.

No entanto, existem componentes que facilitam esse trabalho, como é o caso da Ponte H.

Diagrama de um circuito "Ponte H"

Ponte H é um circuito de eletrônica de potência do tipo chopper de classe E, isto é, que converte uma fonte fixa de corrente contínua, em uma tensão de corrente contínua variável, abrindo e fechando diversas vezes.

Dessa forma, a ponte H pode determinar o sentido da corrente, a polaridade da tensão e a magnitude da tensão, em um dado sistema ou componente.

Seu funcionamento dá-se pelo chaveamento de componentes eletrônicos, usualmente utilizando do método de PWM, para determinar, além da polaridade, o módulo da tensão, em um dado ponto de um circuito.

Tem como principal função, o controle de velocidade e sentido de motores DC escovados, podendo também ser usado para controle da saída de um gerador DC ou como inversor monofásico.

O termo Ponte "H", é derivado da representação gráfica típica deste circuito.

Esquema de Funcionamento

A Ponte H nada mais é que um arranjo de 4 transistores, ou outro componente de chaveamento. Este circuito é uma elegante solução por ser capaz de acionar simultaneamente dois motores controlando não apenas seus sentidos, como também suas velocidades. Além de seu uso ser simples no Arduino.

Funcionamento da ponte H com motores CC

As pontes H em possuem este nome devido ao formato que é montado o circuito, semelhante a letra H.

O circuito utiliza quatro chaves (S1, S2, S3 e S4) que são acionadas de forma alternada, ou seja, (S1-S3) ou (S2-S4), conforme a figura acima.

Fechando-se em conjunto as chaves S1 e S4, o terminal direito do motor fica com uma tensão mais positiva que o esquerdo, fazendo a corrente fluir da direita para a esquerda. Deste modo, o motor adquire sentido de giro que denotaremos por Sentido 1.

Fechando-se em conjunto as chaves S3 e S2, o terminal esquerdo do motor fica com uma tensão mais positiva que o direito, fazendo a corrente fluir da esquerda para a direita. Deste modo, o motor adquire sentido de giro que denotaremos por Sentido 2, que é inverso ao Sentido 1.

Ao acionar em conjunto as chaves S1 e S3 ou S2 e S4 provocamos um curto nos terminais do motor. Isso é necessário quando deseja-se frear um motor já em movimento ou aumentar a dificuldade de giro do eixo por um fator externo.

As chaves S1 e S2 não podem ser fechadas simultaneamente, assim como as chaves S3 e S4, pois o fechamento em conjunto de tais chaves causaria um curto na fonte de alimentação.

Pode-se fazer o uso de PWM nas chaves para controlar a tensão média aplicada sobre o motor, e assim, controlar a velocidade da máquina DC.

Como inversor monofásico, a ativação dos pares de chave ficam se alternado periodicamente, gerando uma frequência definida, e aplica-se PWM a fim de obter-se uma simulação de senoide.

Circuitos auxiliares

Como dito na seção funcionamento, deve-se tomar cuidado para não acionar em conjunto duas chaves que estejam em série, pois isso causaria um curto e danificaria o sistema.

Assim, é indicado o uso de circuitos de proteção, a fim de evitar que ambas as chaves sejam acionadas simultaneamente. Para isso, pode-se utilizar portas lógicas, drivers específicos, ou qualquer outro dispositivo ou circuito que não permita que tal fato aconteça.

Em alguns desses dispositivos e circuitos, ainda é possível adicionar um tempo entre a desativação de uma dessas chaves e a ativação de outra, chamado dead time (tempo morto).

Outro cuidado a se tomar é com correntes e tensões reversas que podem surgir em decorrência do acionamento do motor, que podem causar danos às chaves. Para evitar tais danos, é comum utilizar diodos de ação rápida em anti-paralelo com as chaves, e o uso de TVS.

Os circuitos amaciadores, chamados Snubbers, que são usados para tornar a comutação de estado das chaves menos danosas, e assim prolongar a vida útil do circuito.[2]

Há também, muitas vezes, a necessidade de isolar a parte de controle da parte de potência (a Ponte H em si), ou de trabalhar com tensões diferentes nas duas partes.

Para isso, usa-se circuitos ou componentes isoladores, como opto acopladores ou drivers (programa de acionamento).

O uso de drivers é comum na construção de Pontes H, principalmente nas que usam MOSFETs e IGBTs.

Isso porque, em sua maioria, os drivers condensam uma grande quantidade dos circuitos acima em um único componente, reduzindo espaço, custo e complexidade do projeto, além de facilitar a implementação de circuitos específicos, como o circuito de Bootstrap.

Circuito integrado Ponte H L298N

O CI L298N é muito utilizado para o propósito de controle de motores, ele nada mais é que uma ponte H em um componente integrado.

Uma das vantagens do uso desse CI é o menor espaço ocupado, a baixa complexidade do circuito e o fato de ele já possuir dois circuitos H, podendo assim, controlar dois motores.

Na figura a seguir você pode conferir o diagrama de blocos do CI L298N:

As funções dos principais pinos desse CI são descritas na tabela a seguir:

Funções dos principais pinos da Ponte H L298N

Outra vantagem do L298N é a resposta a sinais de PWM.

Se no lugar de usar sinais lógicos TTL forem usados sinais de PWM, é possível regular a tensão de saída, e dessa forma regular a velocidade dos motores.

O PWM, Pulse Width Modulation (Modulação por Largura de Pulso), consiste basicamente em aplicar uma onda quadrada de amplitude Vcc e frequência alta no lugar da tensão continua Vcc.

Ao usar um sinal de PWM nas entradas IN1 e IN2, por exemplo, teremos uma tensão de saída nos pinos OUT1 e OUT2 em PWM que será igual à Duty Cycle*Vcc. Dessa forma, podemos regular a diferença de potencial média aplicada nos motores, controlando as suas velocidades.

Existem outras opções de CI’s de ponte H no mercado, é importante consultar as especificações deles em suas folhas de dados(Datasheet) para saber qual irá lhe atender melhor. Veja algumas opções de ponte H:

L293D Folha de Dados

LMD18200 Folha de dados.

Circuito integrado Ponte H L293 e L293D

O L293 e L293D são drivers ponte H quádruplos de alta corrente.

O L293 é projetado para prover correntes bidirecionais de até 1 A, às tensões de 4,5V a 36V. O L293D é projetado para prover correntes bidirecionais de até 600 mA, às tensões de 4,5V a 36V.

Ambos os dispositivos são projetados para acionar cargas indutivas, tais como relés, solenóides, motores CC, bem como outras cargas de alta tensão/alta corrente.

Todas as entradas são compatíveis com níveis TTL.

Os drivers são habilitados em pares, com driver 1 e 2 habilitado por 1,2EN e drivers 3 e 4, por 3,4EN. Quando uma entrada de Enable está alta, o driver associado será habilitado e suas saídas estarão ativas e em fase com suas entradas.

Quando a entrada de Enable estiver baixa, esses drivers estarão desabilitados, e suas saídas estarão desligadas, em estado de alta-impedância. Com as entradas apropriadas de dados, cada par de drivers forma um driver Ponte H reversível adequado para as aplicações de solenóide ou motor.

Conexões com o Arduino

• M1 PWM (Enable) - conecte esse pino a um pino PWM do Arduino
• M1 direção 0/1 and M1 direção 1/0 - conecte esses dois a dois pinos digitais do Arduino. Quando a saída um estiver HIGH, e a outra saída, LOW, o motor vai girar em uma direção. Reverter estas saídas para LOW e HIGH vai inverter o motor, que girará na direção contrária.

Código

/************************
 Acionando o motor usando o L2935D
 ************************/
 #define ENABLE 5
 #define DIRA 3
 #define DIRB 4

 int i;
 
 void setup() {
  pinMode(ENABLE,OUTPUT);
  pinMode(DIRA,OUTPUT);
  pinMode(DIRB,OUTPUT);
  Serial.begin(9600);
 }
 
 void loop() {
 //---acionando o motor pra frente e pra trás
  Serial.println("Motor pra frente e pra trás");
  digitalWrite(ENABLE,HIGH); // enable on
  for (i=0;i<5;i++) {
    digitalWrite(DIRA,HIGH); //primeiro sentido de rotação
    digitalWrite(DIRB,LOW);
    delay(500);
    digitalWrite(DIRA,LOW);  //reverte
    digitalWrite(DIRB,HIGH);
    delay(500);
  }
  digitalWrite(ENABLE,LOW); // desabilita o motor
  delay(2000);
  
  Serial.println("exemplo rápido-devagar");
  //---exemplo rápido/devagar/parar
  digitalWrite(ENABLE,HIGH); //enable on
  digitalWrite(DIRA,HIGH); //primeiro sentido de rotação
  digitalWrite(DIRB,LOW);
  delay(3000);
  digitalWrite(ENABLE,LOW); //parada lenta
  delay(1000);
  digitalWrite(ENABLE,HIGH); //enable on
  digitalWrite(DIRA,LOW); //reversão
  digitalWrite(DIRB,HIGH);
  delay(3000);
  digitalWrite(DIRA,LOW); //parada rápida
  delay(2000);
  
  Serial.println("PWM a velocidade plena e depois lenta");
  //---exemplo PWM example, vel máxima, depois lenta
  analogWrite(ENABLE,255); //enable on
  digitalWrite(DIRA,HIGH); //primeiro sentido de rotação
  digitalWrite(DIRB,LOW);
  delay(2000);
  analogWrite(ENABLE,180); //veloc alta
  delay(2000);
  analogWrite(ENABLE,128); //veloc média
  delay(2000);
  analogWrite(ENABLE,50); //veloc baixa
  delay(2000);
  analogWrite(ENABLE,128); //veloc média
  delay(2000);
  analogWrite(ENABLE,180); //veloc alta
  delay(2000);
  analogWrite(ENABLE,255); //veloc máxima
  delay(2000);
  digitalWrite(ENABLE,LOW); //parar
  delay(10000);
}

Módulos Driver motor com Ponte H

Esses módulos são muito utilizados em aplicações de robótica.

Possuem dimensões pequenas e já possuem o circuito básico para o uso do CI, o que facilita na acomodação do módulo no robô ou em outros projetos e a sua utilização.

Existem varias opções disponíveis no mercado, com tamanhos e especificações diferentes.

Algumas especificações são importantes ao escolher seu módulo, são elas:

• Especificação de potência máxima fornecida;
• Tensão máxima suportada;
• Corrente máxima suportada;
• Tensão lógica.

Um exemplo desses módulos é o Ci L298N:

• Tensão para os motores: 5 – 35V;
• Corrente máxima para os motores: 2A;
• Potencia máxima: 25W;
• Tensão lógica: 5V;
• Corrente lógica: 0-36mA;
• Dimensões: 43x43x27 mm
• Peso: 30g.

Permite controlar até 2 motores DC ou 1 motor de passo.

Esse módulo é projetado para controlar cargas indutivas como relés, solenóides, motores DC e motores de passo, permitindo o controle não só do sentido de rotação do motor, como também da sua velocidade, utilizando os pinos PWM do Arduino.

• (Motor A) e (Motor B) se referem aos conectores para ligação de 2 motores DC ou 1 motor de passo
• (Ativa MA) e (Ativa MB) – são os pinos responsáveis pelo controle PWM dos motores A e B. Se estiver com jumper, não haverá controle de velocidade, pois os pinos estarão ligados aos 5v. Esses pinos podem ser utilizados em conjunto com os pinos PWM do Arduino
• (Ativa 5v) e (5v) – Este Driver Ponte H L298N possui um regulador de tensão integrado. Quando o driver está operando entre 6-35V, este regulador disponibiliza uma saída regulada de +5v no pino (5v) para um uso externo (com jumper), podendo alimentar por exemplo outro componente eletrônico. Portanto não alimente este pino (5v) com +5v do Arduino se estiver controlando um motor de 6-35v e jumper conectado, isto danificará a placa. O pino (5v) somente se tornará uma entrada caso esteja controlando um motor de 4-5,5v (sem jumper), assim poderá usar a saída +5v do Arduino.
• (6-35v) e (GND) – Aqui será conectado a fonte de alimentação externa quando o driver estiver controlando um motor que opere entre 6-35v. Por exemplo se estiver usando um motor DC 12v, basta conectar a fonte externa de 12v neste pino e (GND).
• (Entrada) – Este barramento é composto por IN1, IN2, IN3 e IN4. Sendo estes pinos responsáveis pela rotação do Motor A (IN1 e IN2) e Motor B (IN3 e IN4).

A tabela abaixo mostra a ordem de ativação do Motor A através dos pinos IN1 e IN2. O mesmo esquema pode ser aplicado aos pinos IN3 e IN4, que controlam o Motor B

Conectando Ponte H ao Arduino

Vamos mostrar dois esquemas de ligação deste módulo ao Arduino Uno R3, que utilizarão o mesmo programa mostrado no final do post.

O primeiro circuito utiliza a alimentação do próprio Arduino, e deve ser feito sem o Jumper em (Ativa 5V). Utilizamos 2 motores DC 5V.

O segundo circuito utiliza alimentação externa e 2 motores DC de 12V. Nesse caso precisamos colocar o jumper em Ativa 5v:

Programando Ponte H com Arduino

Teste o seu módulo carregando o programa abaixo, que vai servir para os 2 circuitos que mostramos anteriormente.

O programa gira o motor A no sentido horário, depois desliga esse motor e gira o motor B no mesmo sentido. Depois, repete esse procedimento no sentido anti-horário.

CÓDIGO:

//Programa : Controle 2 motores DC usando Ponte H L298N
//Autor : FILIPEFLOP
 
//Definicoes pinos Arduino ligados a entrada da Ponte H
int IN1 = 4;
int IN2 = 5;
int IN3 = 6;
int IN4 = 7;
  
void setup()
{
  //Define os pinos como saida
 pinMode(IN1, OUTPUT);
 pinMode(IN2, OUTPUT);
 pinMode(IN3, OUTPUT);
 pinMode(IN4, OUTPUT);
}
  
void loop()
{
  //Gira o Motor A no sentido horario
  digitalWrite(IN1, HIGH);
  digitalWrite(IN2, LOW);
  delay(2000);
  //Para o motor A
  digitalWrite(IN1, HIGH);
  digitalWrite(IN2, HIGH);
  delay(500);
  //Gira o Motor B no sentido horario
  digitalWrite(IN3, HIGH);
  digitalWrite(IN4, LOW);
  delay(2000);
  //Para o motor B
  digitalWrite(IN3, HIGH);
  digitalWrite(IN4, HIGH);
  delay(500);
  
  //Gira o Motor A no sentido anti-horario
  digitalWrite(IN1, LOW);
  digitalWrite(IN2, HIGH);
  delay(2000);
  //Para o motor A
  digitalWrite(IN1, HIGH);
  digitalWrite(IN2, HIGH);
  delay(500);
  //Gira o Motor B no sentido anti-horario
  digitalWrite(IN3, LOW);
  digitalWrite(IN4, HIGH);
  delay(2000);
  //Para o motor B
  digitalWrite(IN3, HIGH);
  digitalWrite(IN4, HIGH);
  delay(500);
 }

Shield Motor Drive L293D Ponte H

Motor Shield Ponte H para Arduino

A shield, ao contrário do módulo, já vem com os slots prontos para conexão direta com o Arduino, prescindindo de toda fiação para as ligações do circuito:

Na imagem acima, pode-se observar que além de dois L293D, os quais permitem o acionamento de até 4 motores DC, o Motor Shield constitui-se também de um CI 74HC595, um registrador de deslocamento que possibilita uma saída paralela de 8 bits através de uma entrada digital, entrada esta que constitui-se de três pinos: clock, latch e data.

A alimentação do Motor Shield Arduino obedece os limites de tensão estabelecidos pelo Driver L293D e por mais que seja um shield com contato direto no Arduino, a alimentação do Arduino normalmente não é suficiente para o funcionamento dos motores, por isto é necessária uma alimentação externa.

Através do esquema exibido abaixo, podemos observar o borne para para alimentação externa e como dito, este possui limite de alimentação de 4,5 a 36V, ao lado tem-se o jumper de seleção para fonte de alimentação. Quando esse jumper estiver inserido, a alimentação utilizada para os motores é o do próprio Arduino. Se utilizarmos uma fonte externa é fundamental a retirada deste jumper.

Acima vemos o esquema de ligação possível utilizando-se os 4 motores DC conectados ao Motor Shield Arduino, porém vale ressaltar que nestes casos a corrente máxima por porta deve ser de 600mA, utilizarmos as quatro portas teremos um total de 2,4A e a fonte de alimentação utilizada através dos Bornes deve suprir esta necessidade para o total desempenho dos motores.

Especificações:
– Chip: 293D (Datasheet)
– Pode controlar 4 Motores DC, 2 Motores de Passo ou 2 Servos.
– Tensão de saída: 4,5-16V
– Corrente de saída: 600mA por canal
– Até 4 motores DC bi-direcional com seleção individual de velocidades de 8 bits (cerca de 0,5% de resolução).
– Até 2 Motores de Passo (Unipolar ou Bipolar) com bobina unica, dupla ou passos interlaçados.
– 4 Pontes H: 0,6A por Ponte (1,2A de pico) com proteção térmica e diodos de proteção contra retro-alimentação.
– Resistores Pull Down mantem motores desativos durante a entrada de alimentação.
– Botão de Reset Arduino disponível no topo da placa.
– Terminais em bloco de 2 pinos e jumper para conexão de alimentação externa.

Acionamento de um único motor, usando Motor Shield

#include <AFMotor.h>    // Inclui a Biblioteca AFMotor.h
 
AF_DCMotor motor(4);    // Define M4 como posição de controle para motor
 
void setup() {
  motor.setSpeed(200);    // Define velocidade inicial do motor
  motor.run(RELEASE);     // Define a função Stop
 }
 
 void loop() 
 {
    uint8_t i;
    motor.run(FORWARD);           // Liga o Motor
  
    for (i=0; i<255; i++)   {     // Acelera de 0 até a velocidade máxima
       motor.setSpeed(i);
       delay(10);
   }
   
   for (i=255; i!=0; i--)   {    // Diminui da velocidade máxima até 0
      motor.setSpeed(i);
      delay(10);
 }
 
  motor.run(BACKWARD);          // Inverte a direção do motor
 
  for (i=0; i<255; i++)   {     // Acelera de 0 até a velocidade máxima
    motor.setSpeed(i);
    delay(10);
  }
  
  for (i=255; i!=0; i--)   {    // Diminui da velocidade máxima até 0
    motor.setSpeed(i);
    delay(10);
  }
 
  motor.run(RELEASE);           // Desliga o Motor
  delay(1000);
}

Acionamento sem uso da biblioteca - detalhamento do hardware

[1]

Basicamente, o módulo Motor Shield tem um pino serial de entrada, dois pinos de clock (um para deslocar o dado serial e o outro para manter o dado para os pinos de saída, mais os 8 pinos de saída):

• SER: Pino de entrada serial. Usando esse pino, o dado é deslocada serialmente para dentro do modulo. Também chamado de SD (serial data).

SRCLK: Serial clock, to shift in the data from the SER pin. Sometimes this pin is named SH_CP (Shift Clock Pulse) RCLK: Clock to store or latch the shift register content in the device. This pin is sometimes named ST_CP (Store Clock Pulse). QA..QF: 8 output pins of the device. Named as well Q1 to Q7. QH’: Daisy chain pin. Using this pin, multiple 74HC595 devices can be chained. Sometimes named Q7′. Chaining 74HC595 I can chain multiple 74HC595, and thenE I get 8, 16, 24, etc output pins. An excellent tutorial how to use it to drive 16 LEDs (or more) can be found in this article. In this article I’m using just one device, but it is really easy to chain multiple 74HC595.

74HC595 on the Arduino Motor/Stepper/Servo Shield Such a 74HC595 is used on the Arduino Motor/Stepper/Servo Shield introduced in this post. It is that device in the middle of the shield:

Motor Stepper Servo Shield Details Motor Stepper Servo Shield Details

Seen ad many times Not relevant Offensive Covers content Broken REPORT THIS AD

The Eagle Schematics and layout is available on GitHub here.

74HCT595N on Arduino Motor Shield 74HCT595N on Arduino Motor Shield

The 74HCT595N on the Arduino Shield is used to drive 8 motor bridge pins (M1A, M1B, M2A, M2B, M3A, B3B, M4A and M4B). It uses the DIR_EN pin to enable the device. The Ardunio Motor shield schematic is using ‘DIR’ as the signals are used to change the motor direction signals. More about this in the next tutorials.

74HCT595 Shifting To illustrate the shifting of the device, I have connected the device to a logic analyzer:

Probing the 74HCT595N Probing the 74HCT595N

Seen ad many times Not relevant Offensive Covers content Broken REPORT THIS AD

Below I’m shifting in the value 0x03 on the data/DS pin, with the LSB (Least Significant Bit) first. The data gets shifted into the device on each raising edge of the clock signal. At the raising edge of the latch signal, the data shows up on the output pins D0-D7, where D7 has the least significant bit:

74HCT595N Shift Sequence 74HCT595N Shift Sequence

If I have the devices chained, then the D7 bit would be shifted into the next device through the ‘chain’ pin.

FRDM-KL25Z Connections The shift register is connected as below to the FRDM-KL25Z board, as defined by the pin mappings of the shield:

DIR_SER (Serial Input Pin)/DS => Arduino Header D8 => KL25Z pin 33 => PTA13/TPM1_CH1 DIR_CLK (Shift Clock)/SHCP => Arduino Header D4 => KL25Z pin 30 => TSI0_CH5/PTA4/I2C1_SDA/TPM0_CH1/NMI_b DIR_LATCH (Latch clock)/STCP: => Arduino Header D12 => KL25Z pin 76 => PTD3/SPI0_MISO/UART2_TX/TPM0_CH3/SPI0_MOSI DIR_EN (Device Enable)/OE => Arduino Header D7 => KL25Z pin 66 => CMP0_IN3/PTC9/I2C0_SDA/TPM0_CH5 Shift and Latch The following source demonstrates how to shift a byte into the shift register:

DS1 is the data register SHCP1 is the shift clock register void HC595_ShiftByte(byte val) {

 uint8_t i;

 /* precondition: latch pin, data pin and clock pin are all low */
 for(i=0;i<8;i++) { /* shift all the 8 bits */
   /* put data bit */

1. if HC595_SHIFT_MSB_FIRST

   if (val&0x80) { /* LSB bit first */

1. else /* LSB first */

   if (val&1) { /* LSB bit first */

1. endif

     DS1_SetVal();
   } else {
     DS1_ClrVal();
   }
   SHCP1_SetVal(); /* CLK high: data gets transfered into memory */
   DS1_ClrVal(); /* data line low */
   SHCP1_ClrVal(); /* CLK high: data gets transfered into memory */

1. if HC595_SHIFT_MSB_FIRST

   val <<= 1; /* next bit */ #else     val >>= 1; /* next bit */

1. endif

 }

} The macro HC595_SHIFT_MSB_FIRST is used to either shift in the most significant bit first or the least significant one first.

The method ShiftByte() only shifts the 8bits, and does not latch them to to the output pins. So I can use several times the ShiftByte() method if I have chained shift registers.

To latch the bits to the output pins, the Latch() method is using the STCP (Store Clock Pin/Latch):

void HC595_Latch(void)< {

 /* send a latch pulse to show the data on the output pins */
 STCP1_SetVal(); /* set latch to high */
 STCP1_ClrVal(); /* set latch to low */

} For the above pins (DS1, SHCP1 and STCP1) I can use normal GPIO pins in output mode. Pretty easy 🙂

Processor Expert Component To make usage of a 74HCT595 really easy, I have created a Processor Expert component for it. It is available on GitHub with instructions here how to download and install the components.

The component has following properties:

74HC595 Properties 74HC595 Properties

It specifies the interfaces for the mandatory Latch, Data and Clock pins. The OE (Output Enable) pin is optional. Depending on the type of HC595 there might be different delays needed for clock and latch, so the component offers to specify a delay in nanoseconds.

The component offers the following methods:

74HC595 Methods 74HC595 Methods

It has Init() and Deinit() methods for driver initialization and de-initialization. ShiftByte() and Latch() are the methods discussed above. Additionally it features to methods:

ReadByte() returns the latched value. For this it uses a cached (local) variable. WriteByte() does the shifting and latching for a single byte in a single method. Summary Shift registers are very useful to expand the amount of pins of a microcontroller: with a few pins it is possible to have many more pins. Writing a driver for it is not difficult, and I hope the 74HC595 Processor Expert component even makes things easier. As always: the sources are available on GitHub.

List of Tutorials Tutorial: Arduino Motor/Stepper/Servo Shield – Part 1: Servos Tutorial: Arduino Motor/Stepper/Servo Shield – Part 2: Timed Servo Moves Tutorial: Arduino Motor/Stepper/Servo Shield – Part 3: 74HCT595 Shift Register Happy Shifting 🙂

Advertisements Powered by wordads.co Seen ad many times Not relevant Offensive Covers content Broken REPORT THIS AD Advertisements Powered by wordads.co Seen ad many times Not relevant Offensive Covers content Broken REPORT THIS AD SHARE THIS: PrintEmailRedditTwitterFacebookLinkedInTumblrPinterestPocketWhatsAppTelegramSkype

RELATED Tutorial: Arduino Motor/Stepper/Servo Shield - Part 1: Servos In "CodeWarrior" FRDM with Arduino Ethernet Shield R3, Part 1: SD Card In "Boards" Tutorial: Arduino Motor/Stepper/Servo Shield – Part 2: Timed Servo Moves In "Boards" This entry was posted in Embedded, Kinetis, KL25Z Freedom Board and tagged Embedded Component by Erich Styger. Bookmark the permalink.

About Erich Styger Embedded is my passion.... View all posts by Erich Styger → 10 THOUGHTS ON “TUTORIAL: ARDUINO MOTOR/STEPPER/SERVO SHIELD – PART 3: 74HCT595 SHIFT REGISTER” Pingback: Tutorial: Arduino Motor/Stepper/Servo Shield – Part 2: Timed Servo Moves | MCU on Eclipse

Pingback: Tutorial: Arduino Motor/Stepper/Servo Shield – Part 1: Servos | MCU on Eclipse

Karibe on May 10, 2014 at 17:31 said: This worked, have you ever done microstepping?

Like

Reply ↓

Erich Styger on May 10, 2014 at 17:38 said: You mean using a stepper motor with that shield? No, that’s on my growing list of things I want to do, but never had time for it 😦

Like

Reply ↓

Karibe on May 11, 2014 at 20:16 said: Ok, sure I also have a lot to write but no time as I am experimenting. I am using stepper motors from cdroms to build X-Y platform for application in some kind of imaging that requires shifting. DO you know which connection on the stepper motor shield is DIR for changing direction. I cant find anything about that.

Like

Reply ↓

Erich Styger on May 11, 2014 at 20:31 said: A few links: http://digital.ni.com/public.nsf/allkb/0AEE7B9AD4B3E04186256ACE005D833B

http://ssecganesh.blogspot.ch/2008/05/identifying-leads-of-unipolar-stepper.html

Like

Seen ad many times Not relevant Offensive Covers content Broken REPORT THIS AD

Nazário (@NazaBCC) on February 11, 2016 at 11:10 said: I am using in my project the same Arduino Motor/Stepper/Servo Shield and I want know if it is possible to change the pin 12

This part of the code in .h

// Arduino pin names for interface to 74HCT595 latch

1. define MOTORLATCH 12 // I want change this pin 12 for 0, 1 or 2.
2. define MOTORCLK 4
3. define MOTORENABLE 7
4. define MOTORDATA 8

I want to change the pin 12 for another pin. I want to do it, because in my project I need to use this pin 12. I have free the pins 0, 1 e 2 of the my Arduino.

Help me please!

Like

Reply ↓

Erich Styger on February 11, 2016 at 11:20 said: Hello, you need to check the schematics of your board if this is possible at all. Erich

Like

Reply ↓ Saravanan Kannan on January 1, 2018 at 11:09 said: Guys, can anyone send me a simple code to run the dc motor. I tried but not very sure how the ports need to be set. I followed the instruction above to set all the ports for the Shield.

Like

Reply ↓

Erich Styger on January 1, 2018 at 17:22 said: The code is available on GitHub already: https://github.com/ErichStyger/mcuoneclipse/tree/master/Examples/CodeWarrior/FRDM-KL25Z/Freedom_Motor

Like

Reply ↓ What do you think? Enter your comment here... This site uses Akismet to reduce spam. Learn how your comment data is processed.

FOLLOW ME ON TWITTER My Tweets Blog at WordPress.com.

)

Powered by wordads.co Seen ad many times Not relevant Offensive Covers content Broken REPORT THIS AD

O uso de um registrador de deslocamento 74HCT595/SN74HC595 é uma solução que permite extrapolar os pinos de entrada e saída do arduino, em até 8 pinos de saída extras, através do acionamento de 3 pinos do arduino.

So why do I say this for this Arduino Motor/Stepper/Servo Shield tutorial? I have asked in this earlier post with a poll for the next topic (relais, motor or command line interface). Right now votes are mostly for relay. But before I can do relay (or DC motor), I need to first cover the 74HCT559. So here we go to have you ready for the next tutorial 🙂

REPORT THIS AD

 /*
   Aula 69 - Controle do Motor Shield L293D sem Biblioteca
    
   Autor: Eng. Wagner Rambo  Data: Junho de 2016
*/

// --- Mapeamento de Hardware ---
#define   dir_clk      4     //clock do registrador no digital  4
#define   dir_ser      8     //dados do registrador no digital  8
#define   dir_latch   12     //latch do registrador no digital 12
#define   dir_en       7     //enable do registrador no digital 7
#define   pwm2a       11     //pwm motor1
#define   pwm2b        3     //pwm motor2
#define   pwm0a        6     //pwm motor3
#define   pwm0b        5     //pwm motor4
  
// --- Protótipo das Funções Auxiliares ---
void sendCommand(unsigned char value);   //Função para enviar o byte para saída do registrador

// --- Configurações Iniciais ---
void setup() 
{
  pinMode(dir_clk,   OUTPUT);    //saída para clock
 pinMode(dir_ser,   OUTPUT);    //saída para dados
 pinMode(dir_latch, OUTPUT);    //saída para latch
 pinMode(dir_en,    OUTPUT);    //saída para enable
 pinMode(pwm2a,     OUTPUT);    //saída para pwm motor1
 pinMode(pwm2b,     OUTPUT);    //saída para pwm motor2
 pinMode(pwm0a,     OUTPUT);    //saída para pwm motor3
 pinMode(pwm0b,     OUTPUT);    //saída para pwm motor4
 
 digitalWrite(dir_en, LOW);
 analogWrite(pwm2a, 0xFF);
 analogWrite(pwm2b, 0xFF);
 analogWrite(pwm0a, 0xFF);
 analogWrite(pwm0b, 0xFF);

} //end setup

// --- Loop Infinito ---
void loop() 
{
 
 sendCommand(0b10101100);
 delay(2000);
 sendCommand(0b01010011);
 delay(2000);

} //end loop

// --- Desenvolvimento das Funções Auxiliares ---
void sendCommand(unsigned char value)
{

   boolean verify;                  //bit de controle

   digitalWrite(dir_latch, LOW);    //desliga latch
   digitalWrite(dir_clk,   LOW);    //desabilita o clock
  
   for(unsigned char i=0x0; i<0x08; i++)    //loop finito para enviar os 8 bits
   {
      digitalWrite(dir_clk, LOW);   //clock em low
       
      if(value & (1<<i)) verify = HIGH;
      else verify = LOW;
       
      digitalWrite(dir_ser, verify); //Habilita saída de dados conforme condição acima
      digitalWrite(dir_clk, HIGH);
 
   } //end for
 
   digitalWrite(dir_clk, LOW);
 
   digitalWrite(dir_latch, HIGH);

}

---

<< Página do curso

PWM e Acionamento de motores	AULA 7 - Ponte H	Projeto 1 >>