Arduino und MonsterMotorShield

Ein kleines Beispiel wie ihr mit dem Monster Motor Shield 2 Motoren ansteuern könnt:

[code]
/*
 * Das Monster Motor Shield kann mit diesem Sketch über den Seriellen Monitor gesteuert werden.
 * Einfach den Speed und die Richtung durch ein Komma getrennt eingeben.
 * Beispiel: 100,1
 * Dann drehen die Motoren mit der Geschwindigkeit 100 von 255 gegen den Uhrzeigersinn
 * Mögliche Werte:
 * Speed – 0 bis 255 (0 = Stop, 255 = volle Geschwindigkeit)
 * Richtung(Dir) – 0 bis 3 (0 = im Uhrzeigersinn, 1 = gegen den Uhrzeigersinn, 2 = Motoren drehen gegeneinander,
 * 3 = Motoren drehen umgekehrt gegeneinander)
 * Bei einem Fahrzeug mit 2 Motoren wäre das dann:
 * 0 = Vorwärts
 * 1 = Rückwärts
 * 2 = nach links drehen
 * 3 = nach rechts drehen
 *
 * VNH2SP30 pin definitions
 * inApin[2] = {7, 4};  // INA: Clockwise input
 * inBpin[2] = {8, 9}; // INB: Counter-clockwise input
 * pwmpin[2] = {5, 6}; // PWM input
 * cspin[2] = {2, 3}; // CS: Current sense ANALOG input
 * enpin[2] = {0, 1}; // EN: Status of switches output (Analog pin)
 *
 * http://arduinoinc.blogspot.de/
 */

#define CS_THRESHOLD 15   // Der max Strom der durch den Treiber auf Dauer unterstützt wird

int inApin[2] = {7, 4}; // IN-A: Im Uhrzeigersinn drehen, Motor0 and Motor1 (Check:”1.2 Hardware Monster Motor Shield”).
int inBpin[2] = {8, 9}; // IN-B: Gegen den Uhrzeigersinn drehen, Motor0 and Motor1 (Check: “1.2 Hardware Monster Motor Shield”).
int pwmpin[2] = {5, 6};            // PWM’s input
int cspin[2] = {2, 3};              // Strom (A) Sensoren Motor 1/2

int statpin = 13;

int i=0;
int speedon = 0;
int speedaktuell = 0;
int dir = 0;
int diraktuell = 0;

void setup()                        
{
  Serial.begin(9600);
  Serial.println(“Ready to start – Speed,Dir”);
 
  pinMode(statpin, OUTPUT);
 
  for (int i=0; i<2; i++)
      {
        pinMode(inApin[i], OUTPUT);
        pinMode(inBpin[i], OUTPUT);
        pinMode(pwmpin[i], OUTPUT);
      }
     
  for (int i=0; i<2; i++)
      {
        digitalWrite(inApin[i], LOW);
        digitalWrite(inBpin[i], LOW);
      }
}

// **************************************************************

void loop()                         
{

  // Serielle Schnittstelle auslesen
  if (Serial.available() > 0)
  {
      // nach durch “,” getrennte Werte lesen
      speedon = Serial.parseInt();
      dir = Serial.parseInt();
     
      if (Serial.read() == ‘n’)     // nach dem Ende der Zeile schauen
      {
        // Die Werte auf bestimmte Bereiche beschränken
        speedon = constrain(speedon, 0, 255);
        dir = constrain(dir, 0, 3);
      }
     
      Serial.println(“Start”);
      Serial.print(“SpeedOn = “);
      Serial.println(speedon, DEC);
      Serial.print(“Dir = “);
      Serial.println(dir, DEC);
  }
       
 
 
  beschleunigen(speedon, dir);
 
 
 
 
 
  // Auf neue Werte/Anweisungen warten und Überprüfen ob der motor nicht blockiert ist
 
  while(i!=0)
  {                                     
      if (Serial.available() > 0)
      {
        speedon = Serial.parseInt();
        dir = Serial.parseInt();
       
        if (Serial.read() == ‘n’)
        {
            speedon = constrain(speedon, 0, 255);
            dir = constrain(dir, 0, 3);
        }
       
        Serial.print(“SpeedOn = “);
        Serial.println(speedon, DEC);
        Serial.print(“Dir = “);
        Serial.println(dir, DEC);
      }
         
      if (dir != diraktuell) beschleunigen(1, diraktuell);
     
      if (speedaktuell != speedon) beschleunigen(speedon, dir);
     
      motorGo(dir, speedon);
     
      if (analogRead(cspin[0]) > CS_THRESHOLD)        
      {
        motorOff();
      }
     
  }
       
}
// **************************************************************

void beschleunigen(int endspeed, int dirx)
{
  // Beschleunigen des Motors auf “speedon”
  if (endspeed != 0)
  {
      if (endspeed > speedaktuell)  // Wenn die neue Geschwindigkeit größer ist, dann beschleunigen
      {
     
        Serial.println(“beschleunigen”);

        i = speedaktuell;
       
        while(i<endspeed)
        {
          motorGo(dirx, i);   // Den Motorspeed immer um 1/255 erhöhen     
          delay(50);                        
          i++;
                                  
          if (analogRead(cspin[0]) > CS_THRESHOLD) // Ist der Motor blockiert und der Strom wird zuhoch, abschalten.
          {
            motorOff();
          }
         
          digitalWrite(statpin, LOW);
     
        }
      }

      if (endspeed < speedaktuell)  // Wenn die neue Geschwindigkeit kleiner ist, dann entschleunigen
      {
     
        i = speedaktuell;
       
        Serial.println(“entschleunigen”);
       
        while(i>endspeed)
        {
          motorGo(dirx, i);   // Den Motorspeed immer um 1/255 erhöhen     
          delay(50);                        
          i–;
                                  
          if (analogRead(cspin[0]) > CS_THRESHOLD) // Ist der Motor blockiert und der Strom wird zuhoch, abschalten.
          {
            motorOff();
          }
         
          digitalWrite(statpin, LOW);
     
        }
      }
      Serial.println(“Speed erreicht”);
      diraktuell = dir;
      speedaktuell = endspeed;
      i=1;
  }
}

void motorOff()
{

  for (int i=0; i<2; i++)
  {
    digitalWrite(inApin[i], LOW);
    digitalWrite(inBpin[i], LOW);
  }
 
  analogWrite(pwmpin[0], 0);
  analogWrite(pwmpin[1], 0);
 
  i=0;
 
  digitalWrite(13, HIGH);
 
  Serial.println(“Motor Locked”);
 
  delay(1000);
}

void motorGo(uint8_t direct, uint8_t pwm)
{
    if (direct <=4)
    {
      if (direct == 0) // Go forward
      {
        digitalWrite(inBpin[0], LOW);
        digitalWrite(inBpin[1], LOW);
        digitalWrite(inApin[0], HIGH);
        digitalWrite(inApin[1], HIGH);
      }
         
      if (direct == 1)  // Go backward
      {
        digitalWrite(inApin[0], LOW);
        digitalWrite(inApin[1], LOW);
        digitalWrite(inBpin[0], HIGH);
        digitalWrite(inBpin[1], HIGH);
      }
 
      if (direct == 2)  // Go left
      {
        digitalWrite(inApin[0], LOW);
        digitalWrite(inBpin[1], LOW);
        digitalWrite(inBpin[0], HIGH);
        digitalWrite(inApin[1], HIGH);
      }
     
      if (direct == 3)  // Go right
      {
        digitalWrite(inBpin[0], LOW);
        digitalWrite(inApin[1], LOW);
        digitalWrite(inApin[0], HIGH);
        digitalWrite(inBpin[1], HIGH);
      }
       
      analogWrite(pwmpin[0], pwm);
      analogWrite(pwmpin[1], pwm);
    }
}
[/code]

Schreibe einen Kommentar