Shield driver motor L298P

Conexiunile motorului DC

Conexiunile motorului sunt printr-un bloc terminal cu 4 suruburi, cu doua terminatii pentru fiecare motor, etichetate “MOTORA” si “MOTORB”. Pinii +/- pentru fiecare motor nu sunt etichetati, astfel ca realizezi conexiunile intr-un mod oarecum arbitrar si relativ la cum vezi operarea inainte versus operarea invers a motorului. Mai exact, daca motorul merge in directie opusa fata de cea asteptata, trebuie doar sa inversezi conexiunea pentru acel motor.
 

1 x Terminatie cu 4 suruburi (controlul motorului)

• Legatura pozitiva a motorului A
• Legatura negativa a motorului A
• Legatura pozitiva a motorului B
• Legatura negativa a motorului B

Aceste puncte de conexiune la motor sunt reflectate, pentru mai multa flexibilitate, pe o terminatie femela cu 4 pini. Aceste legaturi de actionare a motorului au atasate si LED-uri galbele si verzi, a caror luminozitate variaza in functie de puterea semnalului PWM.
 

1 x 4 Terminatii femela (negre)

• MA = Conexiunea motorului A (x2)
• MB = Conexiunea motorului B (x2)

Conexiunile servomotorului

Servomotoarele sunt dispozitive cu 3 fire si necesita 5V, impamantare si un semnal PWM pentru stabilirea pozitiei. Shieldul utilizeaza D9 pentru semnalul PWM.
 

O caracteristica interesanta a acestor module este regulatorul dedicat de 5V pentru alimentarea servomotorului si prevenirea intoarcerii zgomotului electric in puterea logica de 5V. Servomotoarele sunt, de obicei, utilizate la intoarcerea unui volan mic sau la rotirea unui senzor, cum ar fi senzorul de distanta cu ultrasunete pentru evitarea obstacolelor.
 

Pentru a utiliza servomotorul, ai nevoie de minim 6.3V la conectorul de alimentare a motorului astfel ca regulatorul sa functioneze. Daca nu folosesti un servomotor, poti folosi D9 si cei 5V dedicati in alte scopuri.
 

1x 3 Terinatii servomotor (albe)
 

• G = Impamantare
• +5V = 5V dedicati pentru alimentarea servomotorului
• 9 = D9 este pinul PWM de pe care este pornit servomotorul. Acest pin este disponibil pentru alte utilizari in cazul in care nu este folosit la pornirea unui servomotor.

Conexiunile cu pini intre Arduino si shield

Toate intrarile si iesirile sunt accesibile prin terminatiile femela cu stivuire de pe shiled, exceptand IOREF si cei doi pini I2C de langa conectorul USB, pentru suportul unui shield fiica, atat timp cat nu apare conflictul cu pinii utilizati. In plus, multi dintre acesti pini sunt accesibili altor terminatii pentru conectare usoara.
 

Shieldul utilizeaza urmatorii pini ce raman disponibili daca nu se foloseste functia respectiva:
 

• Controlul senzorului de distanta cu ultrasunete = D7, D8
• Controlul servomotorului = D9
• Controlul motorului DC = D10,D11, D12, D13
• Buzzer = D4

Bluetooth

Pe placa exista doi conectori Bluetooth. Primul conector este o terminatie cu 4 pini pentru putere de 3.3V, impamantare, TX si RX. Acest tip de conector este compatibil cu modulele Bluetooth HC-06 si cu alte modele. Pinul receptor are un divizor de tensiune de 1K/2K pentru schimbarea de nivel la iesirea TX de la Arduino pentru a fi compatibila cu 3.3V.
 

1 x 4 Terminatii Bluetooth femela “BT2” (negre)
 

• ‘+‘ = 3.3V
• ‘–‘ = Impamantare
• T = D0 (RX)
• R = D1 (TX)

Cealalta terminatie Bluetooth este de tip mascul, de 12 pini. TX, RX, 5V si impamantarea sunt legate la aceasta terminatie. Singurii conectori Bluetooth de 12 pini sunt, in general, asociati cu automobile, astfel ca acest conector nu pare sa aiba mare utilitate.
 

Spatierea pinilor este de 2mm si nu de 2.54mm, standard.

Senzor de distanta ultrasonic

O interfata robotica des intalnita este cea a senzorului ultrasonic de distanta, cum este HY-SRF05, care functioneaza trimitand un ping ultrasonic si cronometrand timpul pana la intoarcerea acestuia. Placa are o terminatie de 4 pini pentru conectarea senzorului.
 

1 x 4 Terminatii mascul de ping (galbeni)
 

• + = 5V
• R = Intoarcere (D8)
• T = Declansator (D7)
• G = Impamantare

Senzori analogici/digitali

O problema des intalnita la conectarea senzorilor la un Arduino este necesitatea conexiunilor de impamantare/Vcc, precum si o intrare analogica sau intrare/iesire digitala. Aceasta placa ofera acces la pinii A0-A5 unor terminatii in linie care ofera si separat puncte de putere si impamantare pentru fiecare pin A0-A5. Terminatiile albe sunt liniile de semnal, terminatiile rosii ofera 5V iar cele negre sunt de impamantare.
 

Pinii A0-A5 poti fi utilizati fie pentru intrari analogice, fie ca intrari/iesiri digitale, astfel ca sunt suportate ambele variante de senzori.
 

3 x 6 Terminatii (alb/rosu/negru)
 

• A0 / 5V / Impamantare
• A1 / 5V / Impamantare
• A2 / 5V / Impamantare
• A3 / 5V / Impamantare
• A4 / 5V / Impamantare
• A5 / 5V / Impamantare

Exista, de asemenea, o terminatie cu 3 pini, albastra, pentru cei 5V, impamantare si D2 care poate fi utilizat pentru un senzor digital sau alta conexiune la distanta.
 

1 x 3 Terminatii (albastru)
 

• G = Impamantare
• ‘+‘ = 5V
• S = D2 – I/O digitale

LED RGB

​Ca masura de precautie, exista si terminatia cu 5 pini care ofera D3, D5, D6, 5V si impamantarea. Astfel, 3 iesiri PWM, impreuna cu puterea si impamantarea sunt aduse pe un singur conector, lucru util in multe cazuri, de exemplu la controlul unui LED RGB.
 

1 x 5 Terminatii (albastru)
 

• ‘ ‘ = 5V – Acest pin este nemarcat dar se afla langa D7
• B = D6 – B ar putea fi utilizat pentru culoarea albastru la LED-ul RGB
• G = D5 – G ar putea fi utilizat pentru culoarea verde la LED-ul RGB
• ‘-‘ = Impamantarea
• R = D3 – R ar putea fi utilizat pentru culoarea rosu la LED-ul RGB

Buzzer

Acest buzzer este conectat la D4 si este pe mod activ HIGH. Comutator de resetare Shieldul are un buton de resetare la distanta plasat special pentru acces usor.
 

Exemplu de program pentru shieldul L298P

----

/*
*  L298P Motor Shield
*  Code for exercising the L298P Motor Control portion of the shield
*  The low level motor control logic is kept in the function 'Motor'
*/
// The following pin designations are fixed by the shield
int const BUZZER = 4;
//  Motor A
int const ENA = 10;  
int const INA = 12;
//  Motor B
int const ENB = 11;  
int const INB = 13;

int const MIN_SPEED = 27;   // Set to minimum PWM value that will make motors turn
int const ACCEL_DELAY = 50; // delay between steps when ramping motor speed up or down.
//===============================================================================
//  Initialization
//===============================================================================
void setup()
{
  pinMode(ENA, OUTPUT);   // set all the motor control pins to outputs
  pinMode(ENB, OUTPUT);
  pinMode(INA, OUTPUT);
  pinMode(INB, OUTPUT);
  pinMode(BUZZER, OUTPUT);
  Serial.begin(9600);     // Set comm speed for serial monitor messages
}
//===============================================================================
//  Main
//===============================================================================
void loop()
{
  // Run both motors Forward at 75% power
  Motor('C', 'F', 75);   
  delay(3000);
  
  // Run both motors in Reverse at 75% power but sound beeper first
  Motor('C', 'F', 0);  // Stop motors
  delay(1000);
  digitalWrite(BUZZER,HIGH);delay(500);digitalWrite(BUZZER,LOW); 
  delay(500);
  digitalWrite(BUZZER,HIGH);delay(500);digitalWrite(BUZZER,LOW); 
  delay(1000);
  Motor('C', 'R', 75);  // Run motors forward at 75%
 delay(3000); 
  
  // now run motors in opposite directions at same time at 50% speed
  Motor('A', 'F', 50);
  Motor ('B', 'R', 50);
  delay(3000);
  
  // now turn off both motors
  Motor('C', 'F', 0);  
  delay(3000);

  // Run the motors across the range of possible speeds in both directions
  // Maximum speed is determined by the motor itself and the operating voltage

  // Accelerate from zero to maximum speed
  for (int i = 0; i <= 100; i++)
  {
    Motor('C', 'F', i);
    delay(ACCEL_DELAY);
  }
  delay (2000);
  
  // Decelerate from maximum speed to zero
  for (int i = 100; i >= 0; --i)
  {
    Motor('C', 'F', i);
    delay(ACCEL_DELAY);
  }
  delay (2000);
  
  // Set direction to reverse and accelerate from zero to maximum speed
  for (int i = 0; i <= 100; i++)
  {
    Motor('C', 'R', i);
    delay(ACCEL_DELAY);
  }
  delay (2000);
  
  // Decelerate from maximum speed to zero
  for (int i = 100; i >= 0; --i)
  {
    Motor('C', 'R', i);
    delay(ACCEL_DELAY);
  }
  // Turn off motors
  Motor('C', 'F', 0);
  delay (3000);
}
/*
 * Motor function does all the heavy lifting of controlling the motors
 * mot = motor to control either 'A' or 'B'.  'C' controls both motors.
 * dir = Direction either 'F'orward or 'R'everse
 * speed = Speed.  Takes in 1-100 percent and maps to 0-255 for PWM control.  
 * Mapping ignores speed values that are too low to make the motor turn.
 * In this case, anything below 27, but 0 still means 0 to stop the motors.
 */
void Motor(char mot, char dir, int speed)
{
  // remap the speed from range 0-100 to 0-255
  int newspeed;
  if (speed == 0)
    newspeed = 0;   // Don't remap zero, but remap everything else.
  else
    newspeed = map(speed, 1, 100, MIN_SPEED, 255);

  switch (mot) {
    case 'A':   // Controlling Motor A
      if (dir == 'F') {
        digitalWrite(INA, HIGH);
      }
      else if (dir == 'R') {
        digitalWrite(INB, LOW);
      }
      analogWrite(ENA, newspeed);
      break;

    case 'B':   // Controlling Motor B
      if (dir == 'F') {
        digitalWrite(INB, HIGH);
      }
      else if (dir == 'R') {
        digitalWrite(INB, LOW);
      }
      analogWrite(ENB, newspeed);
      break;

    case 'C':  // Controlling Both Motors
      if (dir == 'F') {
        digitalWrite(INA, HIGH);
        digitalWrite(INB, HIGH);
      }
      else if (dir == 'R') {
        digitalWrite(INA, LOW);
         digitalWrite(INB, LOW);
      }
      analogWrite(ENA, newspeed);
      analogWrite(ENB, newspeed);
      break;
  }
  // Send what we are doing with the motors out to the Serial Monitor.
  
  Serial.print ("Motor: ");
  if (mot=='C')
      Serial.print ("Both");
    else
      Serial.print (mot);
  Serial.print ("t Direction: ");
  Serial.print (dir);
  Serial.print ("t Speed: ");
  Serial.print (speed);
  Serial.print ("t Mapped Speed: ");
  Serial.println (newspeed);
}